diff --git a/src/core/nginx.c b/src/core/nginx.c
index 338f98a..b967393 100644
--- a/src/core/nginx.c
+++ b/src/core/nginx.c
@@ -23,6 +23,346 @@
 ngx_array_t  ngx_listening_sockets;
 
 
+#if 0
+
+int main(int argc, char *const *argv)
+{
+    int          i;
+    ngx_str_t    conf_file;
+    ngx_log_t   *log;
+    ngx_pool_t  *pool;
+    ngx_conf_t   conf;
+
+    ngx_max_sockets = -1;
+
+    log = ngx_log_init_errlog();
+
+    if (ngx_os_init(log) == NGX_ERROR) {
+        return 1;
+    }
+
+    ngx_max_module = 0;
+    for (i = 0; ngx_modules[i]; i++) {
+        ngx_modules[i]->index = ngx_max_module++;
+    }
+
+    ngx_test_null(pool, ngx_create_pool(16 * 1024, log), 1);
+    ngx_test_null(cycle, ngx_pcalloc(pool, sizeof(ngx_cycle_t)), 1);
+    cycle->pool = pool;
+
+    if (ngx_init_conf(cycle) == NGX_ERROR) {
+        return 1;
+    }
+
+    /* daemon */
+
+    /* life cycle */
+
+    for ( ;; ) {
+
+        /* forks */
+
+        ngx_init_temp_number();
+
+        /* threads */
+
+        for ( ;; ) {
+
+            worker(cycle->log);
+
+            pool = ngx_create_pool(16 * 1024, cycle->log);
+
+            if (pool == NULL) {
+                continue;
+            }
+
+            new_cycle = ngx_pcalloc(pool, sizeof(ngx_cycle_t));
+
+            if (new_cycle == NULL) {
+                ngx_destroy_pool(pool);
+                continue;
+            }
+
+            new_cycle->pool = pool;
+
+            if (ngx_init_conf(new_cycle, cycle->log) == NGX_ERROR) {
+                ngx_destroy_pool(new_cycle->pool);
+                continue;
+            }
+
+            nls = new_cycle->listening.elts;
+            for (n = 0; n < new_cycle->listening.nelts; n++) {
+                ls = cycle->listening.elts;
+                for (i = 0; i < cycle->listening.nelts; i++) {
+                    if (ngx_memcmp(nls[n].sockaddr,
+                                   ls[i].sockaddr, ls[i].socklen) == 0)
+                    {
+                        nls[n].fd = ls[i].fd;
+                        break;
+                    }
+                }
+
+                if (nls[n].fd == -1) {
+                    nls[n].new = 1;
+                }
+            }
+
+            if (ngx_open_listening_sockets(new_cycle) == NGX_ERROR) {
+                for (n = 0; n < new_cycle->listening.nelts; n++) {
+                    if (nls[n].new && nls[n].fd != -1) {
+                        if (ngx_close_socket(nls[n].fd) == -1)
+                            ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
+                                          ngx_close_socket_n " %s failed",
+                                          nls[n].addr_text.data);
+                        }
+                    }
+                }
+
+                ngx_destroy_pool(new_cycle->pool);
+                continue;
+            }
+
+            new_cycle->log = new log;
+
+            ngx_destroy_pool(cycle->pool);
+
+            cycle = new_cycle;
+            break;
+        }
+    }
+
+    return 0;
+}
+
+
+static int ngx_init_cycle(ngx_cycle_t *old_cycle, ngx_log_t *log)
+{
+    int           n;
+    ngx_conf_t    conf;
+    ngx_pool_t   *pool;
+    ngx_cycle_t  *cycle;
+
+
+    pool = ngx_create_pool(16 * 1024, log);
+    if (pool == NULL) {
+        return NULL;
+    }
+
+    cycle = ngx_pcalloc(pool, sizeof(ngx_cycle_t));
+    if (cycle == NULL) {
+        ngx_destroy_pool(pool);
+        return NULL;
+    }
+    cycle->pool = pool;
+
+    n = old_cycle ? old_cycle->open_files.nelts : 20;
+    cycle->open_files.elts = ngx_pcalloc(pool, n * sizeof(ngx_open_file_t));
+    if (cycle->open_files.elts == NULL) {
+        ngx_destroy_pool(pool);
+        return NULL;
+    }
+    cycle->open_files.nelts = 0;
+    cycle->open_files.size = sizeof(ngx_open_file_t);
+    cycle->open_files.nalloc = n;
+    cycle->open_files.pool = pool;
+
+    n = old_cycle ? old_cycle->listening.nelts : 10;
+    cycle->listening.elts = ngx_pcalloc(pool, n * sizeof(ngx_listening_t));
+    if (cycle->listening.elts == NULL) {
+        ngx_destroy_pool(pool);
+        return NULL;
+    }
+    cycle->listening.nelts = 0;
+    cycle->listening.size = sizeof(ngx_listening_t);
+    cycle->listening.nalloc = n;
+    cycle->listening.pool = pool;
+
+    cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));
+    if (cycle->conf_ctx == NULL) {
+        ngx_destroy_pool(pool);
+        return NULL;
+    }
+
+    ngx_memzero(&conf, sizeof(ngx_conf_t));
+    /* STUB: init array ? */
+    conf.args = ngx_create_array(pool, 10, sizeof(ngx_str_t));
+    if (conf.args == NULL) {
+        ngx_destroy_pool(pool);
+        return NULL;
+    }
+
+    conf.ctx = cycle->conf_ctx;
+    conf.cycle = cycle;
+    /* STUB */ conf.pool = cycle->pool;
+    conf.log = log;
+    conf.module_type = NGX_CORE_MODULE;
+    conf.cmd_type = NGX_MAIN_CONF;
+
+    conf_file.len = sizeof(NGINX_CONF) - 1;
+    conf_file.data = NGINX_CONF;
+
+    if (ngx_conf_parse(&conf, &conf_file) != NGX_CONF_OK) {
+        ngx_destroy_pool(pool);
+        return NULL;
+    }
+
+    for (i = 0; ngx_modules[i]; i++) {
+        if (ngx_modules[i]->init_module) {
+            if (ngx_modules[i]->init_module(cycle, log) == NGX_ERROR)
+            {
+                failed = 1;
+                break;
+            }
+        }
+    }
+
+    if (!failed) {
+        file = cycle->open_files.elts;
+        for (i = 0; i < cycle->open_files.nelts; i++) {
+            if (file->name.data = NULL) {
+                continue;
+            }
+
+            file->fd = ngx_open_file(file->name.data,
+                                     NGX_FILE_RDWR,
+                                     NGX_FILE_CREATE_OR_OPEN|NGX_FILE_APPEND);
+
+            if (file->fd == NGX_INVALID_FILE) {
+                ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
+                              ngx_open_file_n " \"%s\" failed",
+                              file->name.data);
+                failed = 1;
+                break;
+            }
+
+            /* TODO: Win32 append */
+        }
+    }
+
+    if (!failed) {
+        if (ngx_open_listening_sockets(new_cycle) == NGX_ERROR) {
+            failed = 1;
+        }
+    }
+
+    if (failed) {
+
+        /* rollback the new cycle configuration */
+
+        for (i = 0; ngx_modules[i]; i++) {
+            if (ngx_modules[i]->rollback_module) {
+                ngx_modules[i]->rollback_module(cycle);
+            }
+        }
+
+        file = cycle->open_files.elts;
+        for (i = 0; i < cycle->open_files.nelts; i++) {
+            if (file->fd != NGX_INVALID_FILE) {
+                if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {
+                    ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
+                                  ngx_close_file_n " \"%s\" failed",
+                                  file->name.data);
+                }
+            }
+        }
+
+        ls[i] = cycle->listening.elts;
+        for (i = 0; i < cycle->listening.nelts; i++) {
+            if (ls[i].new && ls[i].fd != -1) {
+                if (ngx_close_socket(ls[i].fd) == -1)
+                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
+                                  ngx_close_socket_n " %s failed",
+                                  ls[i].addr_text.data);
+                }
+            }
+        }
+
+        ngx_destroy_pool(pool);
+        return NULL;
+
+    } else {
+
+        /* commit the new cycle configuration */
+
+        for (i = 0; ngx_modules[i]; i++) {
+            if (ngx_modules[i]->commit_module) {
+                ngx_modules[i]->commit_module(cycle);
+            }
+        }
+    }
+
+    new_cycle->log = ???;
+    pool->log = ???;
+
+    return cycle;
+
+
+
+
+
+
+----------------
+
+    ngx_init_array(cycle->listening, cycle->pool, 10, sizeof(ngx_listening_t),
+                   NGX_ERROR);
+
+    ngx_memzero(&conf, sizeof(ngx_conf_t));
+
+    ngx_test_null(conf.args,
+                  ngx_create_array(cycle->pool, 10, sizeof(ngx_str_t)),
+                  NGX_ERROR);
+
+    ngx_test_null(cycle->conf_ctx,
+                  ngx_pcalloc(cycle->pool, ngx_max_module * sizeof(void *)),
+                  NGX_ERROR);
+
+    conf.ctx = cycle->conf_ctx;
+    conf.cycle = cycle;
+    /* STUB */ conf.pool = cycle->pool; conf.log = cycle->log;
+    conf.module_type = NGX_CORE_MODULE;
+    conf.cmd_type = NGX_MAIN_CONF;
+
+    conf_file.len = sizeof(NGINX_CONF) - 1;
+    conf_file.data = NGINX_CONF;
+
+    if (ngx_conf_parse(&conf, &conf_file) == NGX_CONF_OK) {
+        for (i = 0; ngx_modules[i]; i++) {
+            if (ngx_modules[i]->init_module) {
+                if (ngx_modules[i]->init_module(pool) == NGX_ERROR) {
+                    failed = 1;
+                    break;
+                }
+            }
+        }
+
+    } else {
+        failed = 1;
+    }
+
+    if (failed) {
+        for (i = 0; ngx_modules[i]; i++) {
+            if (ngx_modules[i]->rollback_module) {
+                ngx_modules[i]->rollback_module(pool);
+            }
+        }
+
+        return NGX_ERROR;
+
+    } else {
+        for (i = 0; ngx_modules[i]; i++) {
+            if (ngx_modules[i]->commit_module) {
+                ngx_modules[i]->commit_module(pool);
+            }
+        }
+    }
+
+    return NGX_OK;
+}
+
+
+#endif
+
+
 int main(int argc, char *const *argv)
 {
     int          i;
@@ -44,61 +384,6 @@
         ngx_modules[i]->index = ngx_max_module++;
     }
 
-#if 0
-
-    ngx_test_null(cycle->pool, ngx_create_pool(16 * 1024, log), 1);
-
-    if (ngx_init_conf(cycle) == NGX_ERROR) {
-        ngx_destroy_pool(cycle->pool);
-        return 1;
-    }
-
-    /* daemon */
-
-    /* life cycle */
-
-    {
-
-        /* forks */
-
-        /* threads */
-
-        for ( ;; ) {
-            worker;
-
-            new_cycle = ngx_calloc(sizeof(ngx_cycle_t), cycle->log);
-
-            if (new_cycle == NULL) {
-                continue;
-            }
-
-            new_cycle->pool = ngx_create_pool(16 * 1024, cycle->log);
-
-            if (new_cycle->pool == NULL) {
-                ngx_free(new_cycle);
-                continue;
-            }
-
-            if (ngx_init_conf(new_cycle) == NGX_ERROR) {
-                ngx_destroy_pool(new_cycle->pool);
-                ngx_free(new_cycle);
-                continue;
-            }
-
-            /* update bound listening */
-
-            ngx_destroy_pool(cycle->pool);
-            ngx_free(cycle);
-
-            cycle = new_cycle;
-            break;
-        }
-    }
-
-    return 0;
-
-#endif
-
     /* life cycle */
 
     {
@@ -169,43 +454,6 @@
     return 0;
 }
 
-#if 0
-
-static int ngx_init_conf(ngx_cycle_t *cycle)
-{
-    ngx_conf_t   conf;
-
-    ngx_init_array(cycle->listening, cycle->pool, 10, sizeof(ngx_listening_t),
-                   NGX_ERROR);
-
-    ngx_memzero(&conf, sizeof(ngx_conf_t));
-
-    ngx_test_null(conf.args,
-                  ngx_create_array(cycle->pool, 10, sizeof(ngx_str_t)),
-                  NGX_ERROR);
-
-    ngx_test_null(ngx_conf_ctx,
-                  ngx_pcalloc(cycle->pool, ngx_max_module * sizeof(void *)),
-                  NGX_ERROR);
-
-    conf.ctx = ngx_conf_ctx;
-    conf.pool = cycle->pool;
-    conf.log = cycle->log;
-    conf.module_type = NGX_CORE_MODULE;
-    conf.cmd_type = NGX_MAIN_CONF;
-
-    conf_file.len = sizeof(NGINX_CONF) - 1;
-    conf_file.data = NGINX_CONF;
-
-    if (ngx_conf_parse(&conf, &conf_file) != NGX_CONF_OK) {
-        return NGX_ERROR;
-    }
-
-    return NGX_OK;
-}
-
-
-#endif
 
 static int ngx_open_listening_sockets(ngx_log_t *log)
 {
diff --git a/src/core/ngx_conf_file.h b/src/core/ngx_conf_file.h
index d82d239..e841374 100644
--- a/src/core/ngx_conf_file.h
+++ b/src/core/ngx_conf_file.h
@@ -83,7 +83,9 @@
     ngx_pool_t   *pool;
     ngx_log_t    *log;
     ngx_array_t   listening;
-    ngx_array_t   files;
+    ngx_array_t   open_files;
+
+    unsigned      one_process:1;
 } ngx_cycle_t;
 
 
@@ -95,6 +97,7 @@
     char                 *name;
     ngx_array_t          *args;
 
+    ngx_cycle_t          *cycle;
     ngx_pool_t           *pool;
     ngx_conf_file_t      *conf_file;
     ngx_log_t            *log;
diff --git a/src/core/ngx_modules.c b/src/core/ngx_modules.c
index 0dbcde6..50655ab 100644
--- a/src/core/ngx_modules.c
+++ b/src/core/ngx_modules.c
@@ -6,7 +6,7 @@
 extern ngx_module_t  ngx_errlog_module;
 
 extern ngx_module_t  ngx_events_module;
-extern ngx_module_t  ngx_event_module;
+extern ngx_module_t  ngx_event_core_module;
 extern ngx_module_t  ngx_select_module;
 #if (HAVE_POLL)
 extern ngx_module_t  ngx_poll_module;
@@ -51,7 +51,7 @@
     /* events */
 
     &ngx_events_module,
-    &ngx_event_module,
+    &ngx_event_core_module,
 
     &ngx_select_module,
 #if (HAVE_POLL)
diff --git a/src/core/ngx_string.h b/src/core/ngx_string.h
index 036194b..73ed43a 100644
--- a/src/core/ngx_string.h
+++ b/src/core/ngx_string.h
@@ -18,8 +18,6 @@
 
 #if (WIN32)
 
-#define ngx_memzero               ZeroMemory
-
 #define ngx_strncasecmp           strnicmp
 #define ngx_strcasecmp            stricmp
 #define ngx_strncmp               strncmp
@@ -32,8 +30,6 @@
 
 #else
 
-#define ngx_memzero               bzero
-
 #define ngx_strncasecmp           strncasecmp
 #define ngx_strcasecmp            strcasecmp
 #define ngx_strncmp               strncmp
@@ -46,9 +42,19 @@
 
 #endif
 
+/*
+ * msvc and icc compile memset() to inline "rep stos"
+ * while ZeroMemory and bzero are calls.
+ */
+#define ngx_memzero(buf, n)       memset(buf, n, 0)
+
+/* msvc and icc compile memcpy() to inline "rep movs" */
 #define ngx_memcpy(dst, src, n)   memcpy(dst, src, n)
 #define ngx_cpymem(dst, src, n)   ((char *) memcpy(dst, src, n)) + n
 
+/* msvc and icc compile memcmp() to inline loop */
+#define ngx_memcmp                memcmp
+
 char *ngx_cpystrn(char *dst, char *src, size_t n);
 int ngx_rstrncmp(char *s1, char *s2, size_t n);
 int ngx_atoi(char *line, size_t n);