diff --git a/CMakeLists.txt b/CMakeLists.txt
index e6291a41c..422c1e8b3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,11 +19,18 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_VERBOSE_MAKEFILE OFF)
 
+string(CONCAT UNSTABLE_OPTIMIZATION_OPTIONS # JOIN available if VERSION > 3.12
+  # "-flto " # This optimization causes a SEGV when compiling with Clang 10.
+  # "-fmerge-all-constants " # This optimization is very effective in reducing binary size, but non-standard to the C++ standard.
+  # "-march=native " # This optimization causes "Illegal instruction" error (is Valgrind's bug) on CI.
+  # "-mtune=native "
+  )
+
 set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wpedantic -pipe")
 set(CMAKE_CXX_FLAGS_DEBUG          "-Og -g")
 set(CMAKE_CXX_FLAGS_MINSIZEREL     "-Os    -DNDEBUG")
 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG")
-set(CMAKE_CXX_FLAGS_RELEASE        "-O3    -DNDEBUG") # NOTE: -march=native causes "Illegal instruction" error (is Valgrind's bug) on CI.
+set(CMAKE_CXX_FLAGS_RELEASE        "-O3    -DNDEBUG ${UNSTABLE_OPTIMIZATION_OPTIONS}")
 
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_INSTALL_BINDIR})
@@ -171,6 +178,7 @@ check(internal-definition)
 check(let-syntax)
 check(letrec-syntax)
 check(numerical-operations)
+check(parameterize)
 check(r4rs)
 check(r4rs-appendix)
 check(r5rs)
@@ -178,6 +186,7 @@ check(r7rs)
 check(sicp-1)
 check(srfi-8)
 check(transformer)
+check(with-exception-handler)
 
 file(GLOB ${PROJECT_NAME}_TEST_CXX ${CMAKE_CURRENT_SOURCE_DIR}/test/*.cpp)
 foreach(FILEPATH IN LISTS ${PROJECT_NAME}_TEST_CXX)
diff --git a/README.md b/README.md
index 72b3eb067..7850e3a33 100644
--- a/README.md
+++ b/README.md
@@ -105,9 +105,9 @@ sudo rm -rf /usr/local/share/meevax
 
 | Target Name        | Description
 |:-------------------|:--
-| `all` (default)    | Build shared-library `libmeevax.0.4.232.so` and executable `meevax`.
+| `all` (default)    | Build shared-library `libmeevax.0.4.278.so` and executable `meevax`.
 | `test`             | Test executable `meevax`.
-| `package`          | Generate debian package `meevax_0.4.232_amd64.deb`.
+| `package`          | Generate debian package `meevax_0.4.278_amd64.deb`.
 | `install`          | Copy files into `/usr/local` __(1)__.
 | `install.deb`      | `all` + `package` + `sudo apt install <meevax>.deb`
 | `safe-install.deb` | `all` + `test` + `package` + `sudo apt install <meevax>.deb`
@@ -122,7 +122,7 @@ __(1)__ Meevax installed by `make install` cannot be uninstalled by the system's
 ## Usage
 
 ```
-Meevax Lisp System, version 0.4.232
+Meevax Lisp System, version 0.4.278
 
 Usage: meevax [OPTION...] [FILE...]
 
diff --git a/VERSION b/VERSION
index 2a4561f41..95970ea07 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.4.232
+0.4.278
diff --git a/basis/r4rs-essential.ss b/basis/r4rs-essential.ss
index 815241138..6b8e29524 100644
--- a/basis/r4rs-essential.ss
+++ b/basis/r4rs-essential.ss
@@ -2,7 +2,9 @@
   (import (meevax character)
           (meevax control)
           (meevax environment)
-          (meevax equivalence)
+          (rename (meevax comparator)
+                  (identity=? eq?)
+                  (normally=? eqv?))
           (meevax foreign-function)
           (meevax list)
           (meevax number)
@@ -11,8 +13,7 @@
           (meevax read)
           (meevax string)
           (meevax symbol)
-          (rename (meevax syntax)
-                  (call-with-current-continuation! call-with-current-continuation))
+          (meevax syntax)
           (meevax vector)
           (meevax write)
           (srfi 211 explicit-renaming))
@@ -541,6 +542,9 @@
                (begin (apply map f x xs)
                       (if #f #f))))
 
+         (define (call-with-current-continuation f)
+           (call-with-current-continuation! f))
+
          (define (call-with-input-file path f) ; r7rs incompatible (values unsupported)
            (define (call-with-input-port port f)
              (let ((result (f port)))
diff --git a/basis/r5rs.ss b/basis/r5rs.ss
index 0a61ff1ff..ce59ce93b 100644
--- a/basis/r5rs.ss
+++ b/basis/r5rs.ss
@@ -1,39 +1,48 @@
 (define-library (scheme r5rs continuation)
   (import (meevax context)
-          (only (meevax syntax) define-syntax)
-          (rename (scheme r4rs) (call-with-current-continuation r4rs:call/cc)))
+          (only (meevax dynamic-environment) load-auxiliary store-auxiliary)
+          (only (meevax syntax) define-syntax call-with-current-continuation!)
+          (except (scheme r4rs) call-with-current-continuation))
 
   (export call-with-current-continuation dynamic-wind exit)
 
-  (begin (define %current-dynamic-extents '()) ; https://www.cs.hmc.edu/~fleck/envision/scheme48/meeting/node7.html
+  ; https://www.cs.hmc.edu/~fleck/envision/scheme48/meeting/node7.html
+
+  (begin (define (current-dynamic-extents)
+           (load-auxiliary 0))
+
+         (define (install-dynamic-extents! extents)
+           (store-auxiliary 0 extents))
 
          (define (dynamic-wind before thunk after)
            (before)
-           (set! %current-dynamic-extents (cons (cons before after) %current-dynamic-extents))
+           (install-dynamic-extents! (cons (cons before after)
+                                    (current-dynamic-extents)))
            ((lambda (result) ; TODO let-values
-              (set! %current-dynamic-extents (cdr %current-dynamic-extents))
+              (install-dynamic-extents! (cdr (current-dynamic-extents)))
               (after)
               result) ; TODO (apply values result)
             (thunk)))
 
          (define (call-with-current-continuation procedure)
            (define (windup! from to)
-             (set! %current-dynamic-extents from)
+             (install-dynamic-extents! from)
              (cond ((eq? from to))
                    ((null? from) (windup! from (cdr to)) ((caar to)))
                    ((null? to) ((cdar from)) (windup! (cdr from) to))
                    (else ((cdar from)) (windup! (cdr from) (cdr to)) ((caar to))))
-             (set! %current-dynamic-extents to))
-           (let ((current-dynamic-extents %current-dynamic-extents))
-             (r4rs:call/cc (lambda (k1)
-                             (procedure (lambda (k2)
-                                          (windup! %current-dynamic-extents current-dynamic-extents)
-                                          (k1 k2)))))))
+             (install-dynamic-extents! to))
+           (let ((dynamic-extents (current-dynamic-extents)))
+             (call-with-current-continuation!
+               (lambda (continue)
+                 (procedure (lambda (x)
+                              (windup! (current-dynamic-extents) dynamic-extents)
+                              (continue x)))))))
 
          (define (exit . normally?)
            (for-each (lambda (before/after)
                        ((cdr before/after)))
-                     %current-dynamic-extents)
+                     (current-dynamic-extents))
            (apply emergency-exit normally?))))
 
 (define-library (scheme r5rs)
diff --git a/basis/r7rs.ss b/basis/r7rs.ss
index 0be4d47f6..20565fa4e 100644
--- a/basis/r7rs.ss
+++ b/basis/r7rs.ss
@@ -2,21 +2,11 @@
   (import (only (meevax error) error? read-error? file-error?)
           (only (meevax number) exact-integer?)
           (only (meevax vector) vector-append vector-copy vector-copy! string->vector)
-          (only (meevax port) binary-port?
-                              textual-port?
-                              port?
-                              input-port-open?
-                              output-port-open?
-                              standard-input-port
-                              standard-output-port
-                              standard-error-port
-                              eof-object
-                              get-ready?
-                              get-char
-                              get-char!
-                              put-char
-                              put-string
-                              %flush-output-port)
+          (only (meevax port)
+            binary-port? textual-port? port? input-port-open? output-port-open?
+            standard-input-port standard-output-port standard-error-port
+            eof-object get-ready? get-char get-char! put-char put-string
+            %flush-output-port)
           (only (meevax string) string-copy! vector->string)
           (only (meevax version) features)
           (scheme r5rs)
@@ -61,7 +51,7 @@
           syntax-rules
           _
           ...
-          ; syntax-error
+          syntax-error
           define
           ; define-values
           define-syntax
@@ -286,6 +276,11 @@
                                        (cadr form))
                                 ,@(cddr form)))))
 
+         (define-syntax syntax-error
+           (er-macro-transformer
+             (lambda (form rename compare)
+               (apply error (cdr form)))))
+
          (define (floor-quotient x y)
            (floor (/ x y)))
 
diff --git a/basis/srfi-211.ss b/basis/srfi-211.ss
index 0e00fe979..15e81708b 100644
--- a/basis/srfi-211.ss
+++ b/basis/srfi-211.ss
@@ -13,7 +13,9 @@
   (export sc-macro-transformer rsc-macro-transformer make-syntactic-closure identifier?))
 
 (define-library (srfi 211 explicit-renaming)
-  (import (meevax equivalence)
+  (import (rename (meevax comparator)
+                  (identity=? eq?)
+                  (normally=? eqv?))
           (meevax list)
           (meevax macro)
           (meevax pair)
diff --git a/basis/srfi-34.ss b/basis/srfi-34.ss
index 9e0ffe6de..99735fce9 100644
--- a/basis/srfi-34.ss
+++ b/basis/srfi-34.ss
@@ -19,37 +19,48 @@
 ;  IN THE SOFTWARE.
 
 (define-library (srfi 34)
-  (import (only (meevax error) throw)
+  (import (only (meevax dynamic-environment) load-auxiliary store-auxiliary)
+          (only (meevax error) throw)
           (scheme r5rs))
 
   (export with-exception-handler raise raise-continuable guard)
 
-  (begin (define %current-exception-handlers (list throw))
+  (begin (define (current-exception-handlers)
+           (load-auxiliary 2))
 
-         (define (%with-exception-handlers new-handlers thunk)
-           (let ((old-handlers %current-exception-handlers))
+         (define (install-exception-handlers! handlers)
+           (store-auxiliary 2 handlers))
+
+         (define (with-exception-handlers new-handlers thunk)
+           (let ((old-handlers (current-exception-handlers)))
              (dynamic-wind
-               (lambda () (set! %current-exception-handlers new-handlers)) ; install
+               (lambda () (install-exception-handlers! new-handlers)) ; install
                thunk
-               (lambda () (set! %current-exception-handlers old-handlers))))) ; uninstall
+               (lambda () (install-exception-handlers! old-handlers))))) ; uninstall
 
          (define (with-exception-handler handler thunk)
-           (%with-exception-handlers (cons handler %current-exception-handlers) thunk))
+           (with-exception-handlers (cons handler (current-exception-handlers)) thunk))
 
          (define (raise x)
-           (let ((inner (car %current-exception-handlers))
-                 (outer (cdr %current-exception-handlers)))
-             (%with-exception-handlers outer
+           (let ((inner (car (current-exception-handlers)))
+                 (outer (cdr (current-exception-handlers))))
+             (with-exception-handlers outer
                (lambda ()
-                 (inner x)
-                 (error "If the handler returns, a secondary exception is raised in the same dynamic environment as the handler")))))
+                 (if (procedure? inner)
+                     (inner x)
+                     (throw x))
+                 (throw x)))))
 
          (define (raise-continuable x)
-           (let ((inner (car %current-exception-handlers))
-                 (outer (cdr %current-exception-handlers)))
-             (%with-exception-handlers outer
-                                       (lambda ()
-                                         (inner x)))))
+           (let ((inner (car (current-exception-handlers)))
+                 (outer (cdr (current-exception-handlers))))
+             (with-exception-handlers outer
+               (lambda ()
+                 (if (procedure? inner)
+                     (inner x)
+                     (throw x))))))
+
+         (declare-raiser raise)
 
          (define-syntax guard
            (syntax-rules ()
@@ -107,7 +118,4 @@
                          clause1 clause2 ...)
               (if test
                   (begin result1 result2 ...)
-                  (guard-aux reraise clause1 clause2 ...)))))
-
-         )
-  )
+                  (guard-aux reraise clause1 clause2 ...)))))))
diff --git a/basis/srfi-39.ss b/basis/srfi-39.ss
index a045aa1dc..ae9b8d604 100644
--- a/basis/srfi-39.ss
+++ b/basis/srfi-39.ss
@@ -19,61 +19,48 @@
 ; SOFTWARE.
 
 (define-library (srfi 39)
-  (import (scheme r5rs)
+  (import (only (meevax dynamic-environment) load-auxiliary store-auxiliary)
+          (scheme r5rs)
           (srfi 211 explicit-renaming))
 
   (export make-parameter parameterize)
 
-  (begin (define make-parameter
-           (lambda (init . conv)
-             (let ((converter (if (null? conv)
-                                  (lambda (x) x)
-                                  (car conv))))
-               (let ((global-cell
-                       (cons #f (converter init))))
-                 (letrec ((parameter
-                            (lambda new-val
-                              (let ((cell (dynamic-lookup parameter global-cell)))
-                                (cond ((null? new-val)
-                                       (cdr cell))
-                                      ((null? (cdr new-val))
-                                       (set-cdr! cell (converter (car new-val))))
-                                      (else ; this case is needed for parameterize
-                                        (converter (car new-val))))))))
-                   (set-car! global-cell parameter)
-                   parameter)))))
+  (begin (define (current-dynamic-bindings)
+           (load-auxiliary 1))
 
-         (define dynamic-bind
-           (lambda (parameters values body)
-             (let* ((old-local
-                      (dynamic-env-local-get))
-                    (new-cells
-                      (map (lambda (parameter value)
-                             (cons parameter (parameter value #f)))
-                           parameters
-                           values))
-                    (new-local
-                      (append new-cells old-local)))
-               (dynamic-wind
-                 (lambda () (dynamic-env-local-set! new-local))
-                 body
-                 (lambda () (dynamic-env-local-set! old-local))))))
+         (define (install-dynamic-bindings! bindings)
+           (store-auxiliary 1 bindings))
 
-         (define dynamic-lookup
-           (lambda (parameter global-cell)
-             (or (assq parameter (dynamic-env-local-get))
-                 global-cell)))
+         (define (make-parameter init . converter)
+           (let* ((convert (if (null? converter)
+                               (lambda (x) x)
+                               (car converter)))
+                  (default (cons #f (convert init))))
+             (letrec ((parameter
+                        (lambda value
+                          (let ((cell (or (assq parameter (current-dynamic-bindings)) default)))
+                            (cond ((null? value)
+                                   (cdr cell))
+                                  ((null? (cdr value))
+                                   (set-cdr! cell (convert (car value))))
+                                  (else ; Apply converter to value
+                                    (convert (car value))))))))
+               (set-car! default parameter)
+               parameter)))
 
-         (define dynamic-env-local '())
-
-         (define (dynamic-env-local-get) dynamic-env-local)
-
-         (define (dynamic-env-local-set! new-env)
-           (set! dynamic-env-local new-env))
+         (define (dynamic-bind parameters values body)
+           (let* ((outer (current-dynamic-bindings))
+                  (inner (map (lambda (parameter value)
+                                (cons parameter (parameter value 'apply-converter-to-value)))
+                              parameters
+                              values)))
+             (dynamic-wind (lambda () (install-dynamic-bindings! (append inner outer)))
+                           body
+                           (lambda () (install-dynamic-bindings! outer)))))
 
          (define-syntax parameterize
            (er-macro-transformer
              (lambda (form rename compare)
-               `(,(rename 'dynamic-bind) (,(rename 'list) ,@(map  car (cadr form)))
+               `(,(rename 'dynamic-bind) (,(rename 'list) ,@(map car (cadr form)))
                                          (,(rename 'list) ,@(map cadr (cadr form)))
                                          (,(rename 'lambda) () ,@(cddr form))))))))
diff --git a/include/meevax/kernel/character.hpp b/include/meevax/kernel/character.hpp
index 3965a4511..6ea002f59 100644
--- a/include/meevax/kernel/character.hpp
+++ b/include/meevax/kernel/character.hpp
@@ -17,8 +17,6 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_CHARACTER_HPP
 #define INCLUDED_MEEVAX_KERNEL_CHARACTER_HPP
 
-#include <iostream>
-
 #include <meevax/kernel/pair.hpp>
 
 namespace meevax
diff --git a/include/meevax/kernel/equivalence.hpp b/include/meevax/kernel/comparator.hpp
similarity index 83%
rename from include/meevax/kernel/equivalence.hpp
rename to include/meevax/kernel/comparator.hpp
index 3af9ea328..00a38ce12 100644
--- a/include/meevax/kernel/equivalence.hpp
+++ b/include/meevax/kernel/comparator.hpp
@@ -14,10 +14,10 @@
    limitations under the License.
 */
 
-#ifndef INCLUDED_MEEVAX_KERNEL_EQUIVALENCE_HPP
-#define INCLUDED_MEEVAX_KERNEL_EQUIVALENCE_HPP
+#ifndef INCLUDED_MEEVAX_KERNEL_COMPARATOR_HPP
+#define INCLUDED_MEEVAX_KERNEL_COMPARATOR_HPP
 
-#include <meevax/kernel/boolean.hpp>
+#include <meevax/kernel/pair.hpp>
 
 namespace meevax
 {
@@ -37,4 +37,4 @@ inline namespace kernel
 } // namespace kernel
 } // namespace meevax
 
-#endif // INCLUDED_MEEVAX_KERNEL_EQUIVALENCE_HPP
+#endif // INCLUDED_MEEVAX_KERNEL_COMPARATOR_HPP
diff --git a/include/meevax/kernel/complex.hpp b/include/meevax/kernel/complex.hpp
index 6c6698342..5c5f4d322 100644
--- a/include/meevax/kernel/complex.hpp
+++ b/include/meevax/kernel/complex.hpp
@@ -18,9 +18,7 @@
 #define INCLUDED_MEEVAX_KERNEL_COMPLEX_HPP
 
 #include <complex>
-#include <regex>
 
-#include <meevax/kernel/ghost.hpp>
 #include <meevax/kernel/pair.hpp>
 
 namespace meevax
diff --git a/include/meevax/kernel/configurator.hpp b/include/meevax/kernel/configurator.hpp
index 55aa7120f..de194d368 100644
--- a/include/meevax/kernel/configurator.hpp
+++ b/include/meevax/kernel/configurator.hpp
@@ -19,11 +19,8 @@
 
 #include <regex>
 
-#include <meevax/iostream/concatenate.hpp>
 #include <meevax/kernel/error.hpp>
-#include <meevax/kernel/ghost.hpp>
 #include <meevax/kernel/interaction_environment.hpp>
-#include <meevax/kernel/procedure.hpp>
 #include <meevax/kernel/version.hpp>
 #include <meevax/kernel/writer.hpp>
 
@@ -39,12 +36,12 @@ inline namespace kernel
     explicit configurator()
     {}
 
-    IMPORT(environment, evaluate, NIL);
-    IMPORT(environment, load, NIL);
-    IMPORT(environment, read, NIL);
+    IMPORT(environment, evaluate, );
+    IMPORT(environment, load,     );
+    IMPORT(environment, read,     );
 
     template <typename Key>
-    using dispatcher = std::unordered_map<Key, procedure::function_type>;
+    using dispatcher = std::unordered_map<Key, std::function<void (const_reference)>>;
 
   public:
     static inline auto batch       = false;
@@ -80,49 +77,52 @@ inline namespace kernel
     {
       std::make_pair('b', [](auto&&...)
       {
-        return make<bool>(batch = true);
+        batch = true;
       }),
 
       std::make_pair('d', [](auto&&...)
       {
-        return make<bool>(debug = true);
+        debug = true;
       }),
 
-      std::make_pair('h', [](auto&&...) -> value_type
+      std::make_pair('h', [](auto&&...)
       {
         configurator::display_help();
-        throw exit_status::success;
+        throw success;
       }),
 
       std::make_pair('i', [](auto&&...)
       {
-        return make<bool>(interactive = true);
+        interactive = true;
       }),
 
-      std::make_pair('v', [](auto&&...) -> value_type
+      std::make_pair('t', [](auto&&...)
+      {
+        trace = true;
+      }),
+
+      std::make_pair('v', [](auto&&...)
       {
         configurator::display_version();
-        throw exit_status::success;
+        throw success;
       }),
     };
 
     static inline const dispatcher<char> short_options_with_arguments
     {
-      std::make_pair('e', [](const_reference x, auto&&...)
+      std::make_pair('e', [](auto&& x)
       {
         print(interaction_environment().as<environment>().evaluate(x));
-        return unspecified;
       }),
 
-      std::make_pair('l', [](const_reference x, auto&&...)
+      std::make_pair('l', [](auto&& x)
       {
-        return interaction_environment().as<environment>().load(x.as_const<symbol>());
+        interaction_environment().as<environment>().load(x.template as_const<symbol>());
       }),
 
-      std::make_pair('w', [](const_reference x, auto&&...)
+      std::make_pair('w', [](auto&& x)
       {
         print(x);
-        return unspecified;
       }),
     };
 
@@ -130,54 +130,52 @@ inline namespace kernel
     {
       std::make_pair("batch", [](auto&&...)
       {
-        return make<bool>(batch = true);
+        batch = true;
       }),
 
       std::make_pair("debug", [](auto&&...)
       {
-        return make<bool>(debug = true);
+        debug = true;
       }),
 
-      std::make_pair("help", [](auto&&...) -> value_type
+      std::make_pair("help", [](auto&&...)
       {
         display_help();
-        throw exit_status::success;
+        throw success;
       }),
 
       std::make_pair("interactive", [](auto&&...)
       {
-        return make<bool>(interactive = true);
+        interactive = true;
       }),
 
       std::make_pair("trace", [](auto&&...)
       {
-        return make<bool>(trace = true);
+        trace = true;
       }),
 
-      std::make_pair("version", [](auto&&...) -> value_type
+      std::make_pair("version", [](auto&&...)
       {
         display_version();
-        throw exit_status::success;
+        throw success;
       }),
     };
 
     static inline const dispatcher<std::string> long_options_with_arguments
     {
-      std::make_pair("evaluate", [](const_reference x, auto&&...)
+      std::make_pair("evaluate", [](auto&& x)
       {
         print(interaction_environment().as<environment>().evaluate(x));
-        return unspecified;
       }),
 
-      std::make_pair("load", [](const_reference x, auto&&...)
+      std::make_pair("load", [](auto&& x)
       {
-        return interaction_environment().as<environment>().load(x.as_const<string>());
+        interaction_environment().as<environment>().load(x.template as_const<string>());
       }),
 
-      std::make_pair("write", [](const_reference x, auto&&...)
+      std::make_pair("write", [](auto&& x)
       {
         print(x);
-        return unspecified;
       }),
     };
 
@@ -219,7 +217,7 @@ inline namespace kernel
               }
               else
               {
-                throw error(make<string>(concatenate("option -", name, " requires an argument")));
+                throw std::runtime_error(concatenate("option -", name, " requires an argument"));
               }
             }
             else if (auto iter = short_options.find(*current_short_option); iter != std::end(short_options))
@@ -228,8 +226,7 @@ inline namespace kernel
             }
             else
             {
-              throw error(make<string>("unknown short-option"),
-                          make<symbol>(*current_short_option));
+              throw std::runtime_error(concatenate("unknown short-option ", *current_short_option));
             }
           }
         }
@@ -247,7 +244,7 @@ inline namespace kernel
             }
             else
             {
-              throw error(make<string>(concatenate("option --", current_long_option, " requires an argument")));
+              throw std::runtime_error(concatenate("option --", current_long_option, " requires an argument"));
             }
           }
           else if (auto iter = long_options.find(current_long_option); iter != std::end(long_options))
@@ -256,17 +253,14 @@ inline namespace kernel
           }
           else
           {
-            throw error(make<string>("unknown long-option"),
-                        make<symbol>(*current_option));
+            throw std::runtime_error(concatenate("unknown long-option ", *current_option));
           }
         }
         else
         {
           interactive = false;
-          return load(*current_option);
+          load(*current_option);
         }
-
-        return unspecified;
       }();
     }
   };
diff --git a/include/meevax/kernel/environment.hpp b/include/meevax/kernel/environment.hpp
index 3bd1e1c97..1ddab7f1a 100644
--- a/include/meevax/kernel/environment.hpp
+++ b/include/meevax/kernel/environment.hpp
@@ -21,7 +21,6 @@
 #include <meevax/kernel/machine.hpp>
 #include <meevax/kernel/optimizer.hpp>
 #include <meevax/kernel/reader.hpp>
-#include <meevax/kernel/writer.hpp>
 
 namespace meevax
 {
diff --git a/include/meevax/kernel/error.hpp b/include/meevax/kernel/error.hpp
index 7b5e35b4b..8a97ef8da 100644
--- a/include/meevax/kernel/error.hpp
+++ b/include/meevax/kernel/error.hpp
@@ -17,57 +17,51 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_ERROR_HPP
 #define INCLUDED_MEEVAX_KERNEL_ERROR_HPP
 
-#include <stdexcept>
-
-#include <meevax/kernel/list.hpp>
-#include <meevax/kernel/string.hpp>
-#include <meevax/type_traits/underlying_cast.hpp>
-
-/* ---- Error ------------------------------------------------------------------
- *
- * - error
- *    |-- file-error
- *    |-- read_error
- *    `-- syntax_error
- *
- * -------------------------------------------------------------------------- */
+#include <meevax/kernel/pair.hpp>
 
 namespace meevax
 {
 inline namespace kernel
 {
-  enum class exit_status : int
-  {
-    success = EXIT_SUCCESS,
-    failure = EXIT_FAILURE,
-  };
+  constexpr auto success = EXIT_SUCCESS;
+  constexpr auto failure = EXIT_FAILURE;
 
   struct error : public virtual pair
   {
     using pair::pair;
 
+    explicit error(std::string const&, const_reference = unit);
+
     auto irritants() const noexcept -> const_reference;
 
     auto message() const noexcept -> const_reference;
 
+    [[noreturn]] // NOTE: GCC ignores this attribute when accessed through pointer (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84476)
     virtual auto raise() const -> void;
 
-    virtual auto what() const -> std::string;
+    auto what() const -> std::string;
   };
 
   auto operator <<(std::ostream &, error const&) -> std::ostream &;
 
+  /*
+     - error
+        |-- file-error
+        `-- read_error
+  */
   #define DEFINE_ERROR(TYPENAME)                                               \
   struct TYPENAME ## _error : public error                                     \
   {                                                                            \
     using error::error;                                                        \
                                                                                \
-    ~TYPENAME ## _error() override = default;                                  \
+    auto raise() const -> void override                                        \
+    {                                                                          \
+      throw *this;                                                             \
+    }                                                                          \
   }
 
   DEFINE_ERROR(file);
   DEFINE_ERROR(read);
-  DEFINE_ERROR(syntax);
 
   template <typename Thunk>
   auto with_exception_handler(Thunk && thunk)
@@ -76,35 +70,20 @@ inline namespace kernel
     {
       return thunk();
     }
-
-    catch (exit_status const value) // NOTE: emergency-exit
+    catch (int const status) // NOTE: emergency-exit
     {
-      gc.clear(); // NOTE:
-      return underlying_cast(value);
+      gc.clear();
+      return status;
     }
-
-    catch (const_reference error) // NOTE: procedure `throw` (Terminate the program without running any outstanding dynamic-wind after procedures)
-    {
-      std::cerr << "; " << error << std::endl;
-      return underlying_cast(exit_status::failure);
-    }
-
     catch (error const& error) // NOTE: system-error
     {
       std::cerr << "; " << error << std::endl;
-      return underlying_cast(exit_status::failure);
+      return failure;
     }
-
     catch (std::exception const& error)
     {
-      std::cerr << "; error " << std::quoted(error.what()) << std::endl;
-      return underlying_cast(exit_status::failure);
-    }
-
-    catch (...)
-    {
-      std::cerr << "; error: An unknown object was thrown that was neither a Meevax exception type nor a C++ standard exception type." << std::endl;
-      return underlying_cast(exit_status::failure);
+      std::cerr << "; " << error.what() << std::endl;
+      return failure;
     }
   }
 } // namespace kernel
diff --git a/include/meevax/kernel/heterogeneous.hpp b/include/meevax/kernel/heterogeneous.hpp
index 8f297bb82..9098dd349 100644
--- a/include/meevax/kernel/heterogeneous.hpp
+++ b/include/meevax/kernel/heterogeneous.hpp
@@ -17,18 +17,26 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_POINTER_HPP
 #define INCLUDED_MEEVAX_KERNEL_POINTER_HPP
 
+#include <meevax/functional/combinator.hpp>
 #include <meevax/functional/compose.hpp>
+#include <meevax/iostream/concatenate.hpp>
 #include <meevax/iostream/escape_sequence.hpp>
-#include <meevax/kernel/overview.hpp>
+#include <meevax/iostream/lexical_cast.hpp>
+#include <meevax/kernel/mnemonic.hpp>
 #include <meevax/kernel/profiler.hpp>
+#include <meevax/kernel/type_index.hpp>
+#include <meevax/memory/gc_pointer.hpp>
 #include <meevax/type_traits/is_equality_comparable.hpp>
 #include <meevax/type_traits/is_output_streamable.hpp>
+#include <meevax/utility/demangle.hpp>
 #include <meevax/utility/module.hpp>
 
 namespace meevax
 {
 inline namespace kernel
 {
+  using null = std::nullptr_t;
+
   template <template <typename...> typename Pointer, typename Top, typename... Ts>
   class heterogeneous : public Pointer<Top, Ts...>
   {
@@ -119,9 +127,7 @@ inline namespace kernel
         }
         else
         {
-          std::stringstream ss {};
-          ss << "no viable conversion from " << demangle(type()) << " to " << demangle(typeid(U));
-          raise(ss.str());
+          throw std::runtime_error(concatenate("no viable conversion from ", demangle(type()), " to ", demangle(typeid(U))));
         }
       }
       else
diff --git a/include/meevax/kernel/identity.hpp b/include/meevax/kernel/identity.hpp
index de71a0570..6e742214b 100644
--- a/include/meevax/kernel/identity.hpp
+++ b/include/meevax/kernel/identity.hpp
@@ -17,7 +17,6 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_IDENTITY_HPP
 #define INCLUDED_MEEVAX_KERNEL_IDENTITY_HPP
 
-#include <meevax/kernel/equivalence.hpp>
 #include <meevax/kernel/pair.hpp>
 
 namespace meevax
diff --git a/include/meevax/kernel/instruction.hpp b/include/meevax/kernel/instruction.hpp
index fb9055811..a45b47fa4 100644
--- a/include/meevax/kernel/instruction.hpp
+++ b/include/meevax/kernel/instruction.hpp
@@ -18,7 +18,6 @@
 #define INCLUDED_MEEVAX_KERNEL_INSTRUCTION_HPP
 
 #include <meevax/kernel/pair.hpp>
-#include <meevax/kernel/mnemonic.hpp>
 
 namespace meevax
 {
diff --git a/include/meevax/kernel/intrinsic.hpp b/include/meevax/kernel/intrinsic.hpp
index 47393e254..20800553a 100644
--- a/include/meevax/kernel/intrinsic.hpp
+++ b/include/meevax/kernel/intrinsic.hpp
@@ -28,7 +28,7 @@ inline namespace kernel
                    , public procedure
   {
     template <typename F, typename G>
-    explicit intrinsic(symbol::value_type const& name, F&& f, G&& g)
+    explicit intrinsic(std::string const& name, F&& f, G&& g)
       : syntax    { name, std::forward<decltype(f)>(f) }
       , procedure { name, std::forward<decltype(g)>(g) }
     {}
diff --git a/include/meevax/kernel/library.hpp b/include/meevax/kernel/library.hpp
index 1f7127e64..d73c391ec 100644
--- a/include/meevax/kernel/library.hpp
+++ b/include/meevax/kernel/library.hpp
@@ -17,9 +17,7 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_LIBRARY_HPP
 #define INCLUDED_MEEVAX_KERNEL_LIBRARY_HPP
 
-#include <functional>
 #include <meevax/kernel/environment.hpp>
-#include <unordered_map>
 
 namespace meevax
 {
diff --git a/include/meevax/kernel/list.hpp b/include/meevax/kernel/list.hpp
index 57172c2e8..d78301e8d 100644
--- a/include/meevax/kernel/list.hpp
+++ b/include/meevax/kernel/list.hpp
@@ -19,9 +19,8 @@
 
 #include <algorithm>
 
-#include <meevax/functional/combinator.hpp>
-#include <meevax/kernel/equivalence.hpp>
-#include <meevax/kernel/exact_integer.hpp>
+#include <meevax/kernel/boolean.hpp>
+#include <meevax/kernel/comparator.hpp>
 #include <meevax/kernel/iterator.hpp>
 
 namespace meevax
@@ -29,7 +28,7 @@ namespace meevax
 inline namespace kernel
 {
   template <auto N, typename T>
-  auto field(T&& x) -> decltype(auto)
+  auto get(T&& x) -> decltype(auto)
   {
     if constexpr (std::is_same_v<std::decay_t<decltype(x)>, iterator>)
     {
@@ -47,12 +46,12 @@ inline namespace kernel
 
   inline auto car = [](auto&& x) -> decltype(auto)
   {
-    return field<0>(std::forward<decltype(x)>(x));
+    return get<0>(std::forward<decltype(x)>(x));
   };
 
   inline auto cdr = [](auto&& x) -> decltype(auto)
   {
-    return field<1>(std::forward<decltype(x)>(x));
+    return get<1>(std::forward<decltype(x)>(x));
   };
 
   template <typename T, typename U, REQUIRES(std::is_convertible<T, value_type>,
diff --git a/include/meevax/kernel/machine.hpp b/include/meevax/kernel/machine.hpp
index 4c11ebea8..8db6d6848 100644
--- a/include/meevax/kernel/machine.hpp
+++ b/include/meevax/kernel/machine.hpp
@@ -17,7 +17,6 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_MACHINE_HPP
 #define INCLUDED_MEEVAX_KERNEL_MACHINE_HPP
 
-#include <meevax/iostream/lexical_cast.hpp>
 #include <meevax/kernel/closure.hpp>
 #include <meevax/kernel/continuation.hpp>
 #include <meevax/kernel/ghost.hpp>
@@ -48,6 +47,33 @@ inline namespace kernel
         c, // code (instructions yet to be executed)
         d; // dump (s e c . d)
 
+    std::array<let, 3> a; /* auxiliary register
+
+       a[0] is used for current-dynamic-extents.
+       a[1] is used for current-dynamic-bindings.
+       a[2] is used for current-exception-handler.
+       a[3] is currently unused. */
+
+    let raiser; /*
+
+       raiser is a one-argument procedure for propagating C++ exceptions thrown
+       in the Meevax kernel to the exception handler of the language running on
+       the Meevax kernel.
+
+       raiser is set to null by default. In this default state, that is, if
+       raiser is null, C++ exceptions thrown in the kernel are rethrown to the
+       outer environment.
+
+       Although raiser can be set to any one-argument procedure by
+       `declare-raiser` declaration, it is basically assumed to be set to
+       R7RS Scheme's standard procedure `raise`.
+
+       The value of raiser is propagated by the import declaration. Currently,
+       in the Scheme standard library provided by Meevax, the procedure `raise`
+       is defined in the library (srfi 34), and `declare-raiser` is also
+       declared in (srfi 34). This means that environments that depend on the
+       library (srfi 34) will automatically declare `raise` as raiser. */
+
     struct transformer
     {
       let const expression;
@@ -192,7 +218,7 @@ inline namespace kernel
       {
         return cons(make(mnemonic::load_constant), unit, current_continuation);
       }
-      else if (not current_expression.is<pair>()) /* -----------------------------------
+      else if (not current_expression.is<pair>()) /* ---------------------------
       *
       *  <variable>                                                      syntax
       *
@@ -319,7 +345,7 @@ inline namespace kernel
     }
 
     template <auto trace = false>
-    inline auto execute() -> value_type
+    inline auto execute() -> value_type try
     {
     decode:
       if constexpr (trace)
@@ -401,6 +427,15 @@ inline namespace kernel
         c = cddr(c);
         goto decode;
 
+      case mnemonic::load_auxiliary: /* ----------------------------------------
+        *
+        *  s e (%load-auxiliary i . c) => (a[i] . s) e c d
+        *
+        * ------------------------------------------------------------------- */
+        s = cons(a[cadr(c).template as<exact_integer>()], s);
+        c = cddr(c);
+        goto decode;
+
       case mnemonic::select: /* ------------------------------------------------
         *
         *  (<boolean> . s) e (%select c1 c2 . c) d => s e c' (c . d)
@@ -583,7 +618,7 @@ inline namespace kernel
         }
         else
         {
-          throw error(make<string>("not applicable"), callee);
+          throw std::runtime_error(concatenate("not applicable ", callee));
         }
 
       case mnemonic::dummy: /* -------------------------------------------------
@@ -663,6 +698,15 @@ inline namespace kernel
         c = cddr(c);
         goto decode;
 
+      case mnemonic::store_auxiliary: /* ---------------------------------------
+        *
+        *  (x . s) e (%store-auxiliary i . c) d => (x . s) e c d
+        *
+        * ------------------------------------------------------------------- */
+        a[cadr(c).template as<exact_integer>()] = car(s);
+        c = cddr(c);
+        goto decode;
+
       default: // ERROR
       case mnemonic::stop: /* --------------------------------------------------
         *
@@ -683,6 +727,14 @@ inline namespace kernel
         }();
       }
     }
+    catch (std::exception const& exception)
+    {
+      return raise(make<error>(make<string>(exception.what())));
+    }
+    catch (error const& error)
+    {
+      return raise(make(error));
+    }
 
     static auto identify(const_reference variable, const_reference scope) -> value_type
     {
@@ -718,6 +770,22 @@ inline namespace kernel
       return variable.is<syntactic_closure>() ? variable.as<syntactic_closure>().identify_with_offset(scope) : f;
     }
 
+    inline auto raise(const_reference x) -> value_type
+    {
+      if (raiser.is<null>())
+      {
+        throw x;
+        return unspecified;
+      }
+      else
+      {
+        s = list(raiser, list(x));
+        c = list(make(mnemonic::tail_call), make(mnemonic::stop));
+
+        return execute();
+      }
+    }
+
     [[deprecated]]
     inline auto reset() -> void
     {
@@ -750,6 +818,30 @@ inline namespace kernel
                           current_continuation));
     }
 
+    static SYNTAX(load_auxiliary) /* -------------------------------------------
+    *
+    *  (load-auxiliary <index>)                                          syntax
+    *
+    * ----------------------------------------------------------------------- */
+    {
+      return cons(make(mnemonic::load_auxiliary), car(current_expression),
+                  current_continuation);
+    }
+
+    static SYNTAX(store_auxiliary) /* ------------------------------------------
+    *
+    *  (store-auxiliary <index> <expression>)                            syntax
+    *
+    * ----------------------------------------------------------------------- */
+    {
+      return compile(context(),
+                     current_environment,
+                     cadr(current_expression),
+                     current_scope,
+                     cons(make(mnemonic::store_auxiliary), car(current_expression),
+                          current_continuation));
+    }
+
     static SYNTAX(body)
     {
       auto is_definition = [&](const_reference form)
@@ -988,7 +1080,7 @@ inline namespace kernel
       }
       else
       {
-        throw syntax_error(make<string>("definition cannot appear in this syntactic-context"));
+        throw error("definition cannot appear in this syntactic-context");
       }
     }
 
diff --git a/include/meevax/kernel/mnemonic.hpp b/include/meevax/kernel/mnemonic.hpp
index 49e2c86d9..73883c791 100644
--- a/include/meevax/kernel/mnemonic.hpp
+++ b/include/meevax/kernel/mnemonic.hpp
@@ -36,6 +36,7 @@ inline namespace kernel
     letrec,            // a.k.a RAP
     letrec_syntax,     //
     load_absolute,     // a.k.a LDG
+    load_auxiliary,    //
     load_closure,      // a.k.a LDF
     load_constant,     // a.k.a LDC
     load_continuation, //
@@ -45,6 +46,7 @@ inline namespace kernel
     select,            // a.k.a SEL
     stop,              //
     store_absolute,    //
+    store_auxiliary,   //
     store_relative,    //
     store_variadic,    //
     tail_call,         //
diff --git a/include/meevax/kernel/number.hpp b/include/meevax/kernel/number.hpp
index bac05f62b..b218c3f38 100644
--- a/include/meevax/kernel/number.hpp
+++ b/include/meevax/kernel/number.hpp
@@ -17,15 +17,10 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_NUMERICAL_HPP
 #define INCLUDED_MEEVAX_KERNEL_NUMERICAL_HPP
 
-#include <meevax/iostream/concatenate.hpp>
-#include <meevax/kernel/boolean.hpp>
 #include <meevax/kernel/complex.hpp>
-#include <meevax/kernel/error.hpp>
 #include <meevax/kernel/exact_integer.hpp>
-#include <meevax/kernel/procedure.hpp>
 #include <meevax/kernel/ratio.hpp>
 #include <meevax/kernel/string.hpp>
-#include <meevax/kernel/type_index.hpp>
 
 namespace meevax
 {
diff --git a/include/meevax/kernel/object.hpp b/include/meevax/kernel/object.hpp
deleted file mode 100644
index afe3cab7f..000000000
--- a/include/meevax/kernel/object.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-   Copyright 2018-2022 Tatsuya Yamasaki.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-#ifndef INCLUDED_MEEVAX_KERNEL_OBJECT_HPP
-#define INCLUDED_MEEVAX_KERNEL_OBJECT_HPP
-
-#include <meevax/kernel/heterogeneous.hpp>
-
-namespace meevax
-{
-inline namespace kernel
-{
-  template <typename T>
-  struct top
-  {
-    virtual auto compare(T const* p) const -> bool
-    {
-      if constexpr (is_equality_comparable<T>::value)
-      {
-        return p ? *p == static_cast<T const&>(*this) : std::is_same<T, null>::value;
-      }
-      else
-      {
-        return false;
-      }
-    }
-
-    virtual auto type() const noexcept -> std::type_info const&
-    {
-      return typeid(T);
-    }
-
-    virtual auto write(std::ostream & os) const -> std::ostream &
-    {
-      return os << static_cast<T const&>(*this);
-    }
-  };
-
-  template <typename T, typename... Ts>
-  auto make(Ts&&... xs)
-  {
-    return value_type::allocate<T>(std::forward<decltype(xs)>(xs)...); // NOTE: This leaks memory if exception thrown from T's constructor.
-  }
-
-  template <typename T>
-  auto make(T&& x)
-  {
-    return value_type::allocate<std::decay_t<T>>(std::forward<decltype(x)>(x));
-  }
-} // namespace kernel
-} // namespace meevax
-
-#endif // INCLUDED_MEEVAX_KERNEL_OBJECT_HPP
diff --git a/include/meevax/kernel/optimizer.hpp b/include/meevax/kernel/optimizer.hpp
index e8211f12d..00ed50b51 100644
--- a/include/meevax/kernel/optimizer.hpp
+++ b/include/meevax/kernel/optimizer.hpp
@@ -61,9 +61,11 @@ inline namespace kernel
       case mnemonic::let_syntax:
       case mnemonic::letrec_syntax:
       case mnemonic::load_absolute:
+      case mnemonic::load_auxiliary:
       case mnemonic::load_relative:
       case mnemonic::load_variadic:
       case mnemonic::store_absolute:
+      case mnemonic::store_auxiliary:
       case mnemonic::store_relative:
       case mnemonic::store_variadic:
         return [&]()
diff --git a/include/meevax/kernel/overview.hpp b/include/meevax/kernel/overview.hpp
deleted file mode 100644
index ea272d156..000000000
--- a/include/meevax/kernel/overview.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-   Copyright 2018-2022 Tatsuya Yamasaki.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-#ifndef INCLUDED_MEEVAX_KERNEL_OVERVIEW_HPP
-#define INCLUDED_MEEVAX_KERNEL_OVERVIEW_HPP
-
-#include <meevax/kernel/mnemonic.hpp>
-#include <meevax/memory/gc_pointer.hpp>
-#include <meevax/type_traits/requires.hpp>
-#include <meevax/utility/demangle.hpp>
-
-#define NIL /* nothing */
-
-namespace meevax
-{
-inline namespace kernel
-{
-  class environment;
-
-  struct error;          // error.hpp
-  struct exact_integer;  // exact_integer.hpp
-  struct pair;           // pair.hpp
-  struct ratio;          // ratio.hpp
-  struct vector;         // vector.hpp
-
-  template <template <typename...> typename, typename, typename...>
-  class heterogeneous;
-
-  using value_type = heterogeneous<gc_pointer, pair, bool, std::int32_t, std::uint32_t, float, mnemonic>;
-
-  using reference = value_type &;
-
-  using const_reference = value_type const&;
-
-  using let = value_type;
-
-  using null = std::nullptr_t;
-
-  [[noreturn]]
-  auto raise(std::string const&) -> void; // error.hpp
-} // namespace kernel
-} // namespace meevax
-
-#endif // INCLUDED_MEEVAX_KERNEL_OVERVIEW_HPP
diff --git a/include/meevax/kernel/pair.hpp b/include/meevax/kernel/pair.hpp
index 8fc2e7386..e26671d6d 100644
--- a/include/meevax/kernel/pair.hpp
+++ b/include/meevax/kernel/pair.hpp
@@ -17,30 +17,52 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_PAIR_HPP
 #define INCLUDED_MEEVAX_KERNEL_PAIR_HPP
 
-#include <meevax/kernel/object.hpp>
+#include <meevax/kernel/heterogeneous.hpp>
 
 namespace meevax
 {
 inline namespace kernel
 {
+  struct pair;
+
+  using value_type = heterogeneous<gc_pointer, pair, bool, std::int32_t, std::uint32_t, float, mnemonic>;
+
+  using reference = value_type &;
+
+  using const_reference = value_type const&;
+
+  using let = value_type;
+
   let extern unit;
 
+  template <typename T, typename... Ts>
+  auto make(Ts&&... xs)
+  {
+    return value_type::allocate<T>(std::forward<decltype(xs)>(xs)...); // NOTE: This leaks memory if exception thrown from T's constructor.
+  }
+
   template <typename T>
-  using pair_of = std::pair<T, T>;
+  auto make(T&& x)
+  {
+    return value_type::allocate<std::decay_t<T>>(std::forward<decltype(x)>(x));
+  }
 
-  struct pair : public pair_of<value_type>
-              , public top<pair>
+  struct pair : public std::pair<value_type, value_type>
   {
-    explicit pair(const_reference a = unit, const_reference b = unit)
-      : pair_of<value_type> { a, b }
-    {}
+    explicit pair(const_reference = unit, const_reference = unit);
 
-    template <typename... Ts, typename = typename std::enable_if<(1 < sizeof...(Ts))>::type>
+    template <typename... Ts, typename = std::enable_if_t<(1 < sizeof...(Ts))>>
     explicit pair(const_reference a, Ts&&... xs)
-      : pair_of<value_type> { a, make<pair>(std::forward<decltype(xs)>(xs)...) }
+      : pair { a, make<pair>(std::forward<decltype(xs)>(xs)...) }
     {}
 
     virtual ~pair() = default;
+
+    virtual auto compare(pair const*) const -> bool;
+
+    virtual auto type() const noexcept -> std::type_info const&;
+
+    virtual auto write(std::ostream &) const -> std::ostream &;
   };
 
   auto operator <<(std::ostream &, pair const&) -> std::ostream &;
diff --git a/include/meevax/kernel/port.hpp b/include/meevax/kernel/port.hpp
index f9b9a8b50..61dfe0927 100644
--- a/include/meevax/kernel/port.hpp
+++ b/include/meevax/kernel/port.hpp
@@ -19,8 +19,7 @@
 
 #include <fstream>
 
-#include <meevax/kernel/pair.hpp>
-#include <meevax/utility/description.hpp>
+#include <meevax/kernel/string.hpp>
 
 namespace meevax
 {
@@ -43,9 +42,12 @@ inline namespace kernel
   #undef DEFINE
 
   #define DEFINE(TYPENAME, FILE_STREAM)                                        \
-  struct TYPENAME : public description                                         \
-                  , public FILE_STREAM                                         \
+  struct TYPENAME : public FILE_STREAM                                         \
   {                                                                            \
+    string const pathname;                                                     \
+                                                                               \
+    explicit TYPENAME(string const&);                                          \
+                                                                               \
     explicit TYPENAME(std::string const&);                                     \
   };                                                                           \
                                                                                \
diff --git a/include/meevax/kernel/procedure.hpp b/include/meevax/kernel/procedure.hpp
index be855be57..56a9dac88 100644
--- a/include/meevax/kernel/procedure.hpp
+++ b/include/meevax/kernel/procedure.hpp
@@ -18,8 +18,6 @@
 #define INCLUDED_MEEVAX_KERNEL_PROCEDURE_HPP
 
 #include <meevax/kernel/list.hpp>
-#include <meevax/kernel/symbol.hpp>
-#include <meevax/utility/description.hpp>
 
 namespace meevax
 {
@@ -27,21 +25,23 @@ inline namespace kernel
 {
   #define PROCEDURE(...) meevax::value_type __VA_ARGS__(meevax::const_reference xs)
 
-  struct procedure : public description
+  struct procedure
   {
     using function_pointer_type = PROCEDURE((*));
 
     using function_type = std::function<PROCEDURE()>;
 
+    std::string const name;
+
     function_type call;
 
-    explicit procedure(symbol::value_type const&, function_type const&);
+    explicit procedure(std::string const&, function_type const&);
 
-    explicit procedure(symbol::value_type const&, symbol::value_type const&);
+    explicit procedure(std::string const&, std::string const&);
 
-    static auto dlopen(symbol::value_type const&) -> void *;
+    static auto dlopen(std::string const&) -> void *;
 
-    static auto dlsym(symbol::value_type const&, void * const) -> function_pointer_type;
+    static auto dlsym(std::string const&, void * const) -> function_pointer_type;
   };
 
   auto operator <<(std::ostream &, procedure const&) -> std::ostream &;
@@ -49,7 +49,7 @@ inline namespace kernel
   struct predicate : public procedure
   {
     template <typename Callable>
-    explicit predicate(symbol::value_type const& name, Callable && call)
+    explicit predicate(std::string const& name, Callable && call)
       : procedure { name, [call](auto&&... xs) { return call(std::forward<decltype(xs)>(xs)...) ? t : f; } }
     {}
   };
diff --git a/include/meevax/kernel/reader.hpp b/include/meevax/kernel/reader.hpp
index 8b100fa66..31adf5a68 100644
--- a/include/meevax/kernel/reader.hpp
+++ b/include/meevax/kernel/reader.hpp
@@ -17,7 +17,6 @@
 #ifndef INCLUDED_MEEVAX_KERNEL_READER_HPP
 #define INCLUDED_MEEVAX_KERNEL_READER_HPP
 
-#include <meevax/iostream/lexical_cast.hpp>
 #include <meevax/kernel/eof.hpp>
 #include <meevax/kernel/error.hpp>
 #include <meevax/kernel/ghost.hpp>
@@ -60,7 +59,7 @@ inline namespace kernel
     explicit reader()
     {}
 
-    IMPORT(Environment, evaluate, NIL);
+    IMPORT(Environment, evaluate, );
 
     using char_type = typename std::istream::char_type;
 
@@ -151,7 +150,7 @@ inline namespace kernel
             return read(is);
 
           default:
-            throw read_error(make<string>("unknown discriminator"), make<character>(c));
+            throw read_error("unknown discriminator", make<character>(c));
           }
 
         case '\'': // 0x27
@@ -255,7 +254,7 @@ inline namespace kernel
       }
       else
       {
-        throw error(make<string>("failed to intern a symbol"), make<string>(name));
+        throw std::runtime_error(concatenate("failed to intern a symbol '", name));
       }
     }
   };
diff --git a/include/meevax/kernel/string.hpp b/include/meevax/kernel/string.hpp
index 74a63d161..3a78dde52 100644
--- a/include/meevax/kernel/string.hpp
+++ b/include/meevax/kernel/string.hpp
@@ -69,7 +69,7 @@ inline namespace kernel
 
        In both procedures, order is preserved.
     */
-    explicit string(vector const&, const_reference, const_reference);
+    explicit string(const_reference, const_reference, const_reference);
 
     /*
        (string-append string ...)                                     procedure
diff --git a/include/meevax/kernel/syntax.hpp b/include/meevax/kernel/syntax.hpp
index fd17e3b84..cc36713c2 100644
--- a/include/meevax/kernel/syntax.hpp
+++ b/include/meevax/kernel/syntax.hpp
@@ -19,8 +19,6 @@
 
 #include <meevax/kernel/context.hpp>
 #include <meevax/kernel/pair.hpp>
-#include <meevax/kernel/symbol.hpp>
-#include <meevax/utility/description.hpp>
 
 #define SYNTAX(NAME)                                                           \
   auto NAME(                                                                   \
@@ -34,15 +32,19 @@ namespace meevax
 {
 inline namespace kernel
 {
-  struct syntax : public description
+  class environment; // environment.hpp
+
+  struct syntax
   {
     using function_pointer_type = SYNTAX((*));
 
     using function_type = std::function<SYNTAX()>;
 
-    function_type compile;
+    std::string const name;
+
+    function_type const compile;
 
-    explicit syntax(symbol::value_type const&, function_type const&);
+    explicit syntax(std::string const&, function_type const&);
   };
 
   auto operator <<(std::ostream &, syntax const&) -> std::ostream &;
diff --git a/include/meevax/memory/collector.hpp b/include/meevax/memory/collector.hpp
index a70fe202b..21b9752e8 100644
--- a/include/meevax/memory/collector.hpp
+++ b/include/meevax/memory/collector.hpp
@@ -17,7 +17,6 @@
 #ifndef INCLUDED_MEEVAX_MEMORY_COLLECTOR_HPP
 #define INCLUDED_MEEVAX_MEMORY_COLLECTOR_HPP
 
-#include <cassert>
 #include <cstddef>
 #include <limits>
 #include <map>
@@ -27,7 +26,6 @@
 
 #include <meevax/memory/tracer.hpp>
 #include <meevax/memory/simple_allocator.hpp>
-#include <meevax/string/header.hpp>
 
 namespace meevax
 {
diff --git a/include/meevax/memory/nan_boxing_pointer.hpp b/include/meevax/memory/nan_boxing_pointer.hpp
index 7067effc9..3ee7f135f 100644
--- a/include/meevax/memory/nan_boxing_pointer.hpp
+++ b/include/meevax/memory/nan_boxing_pointer.hpp
@@ -22,7 +22,6 @@
 #include <iomanip>
 #include <memory>
 #include <ostream>
-#include <type_traits>
 #include <typeinfo>
 
 #include <meevax/memory/bit_cast.hpp>
diff --git a/include/meevax/utility/description.hpp b/include/meevax/utility/description.hpp
deleted file mode 100644
index 205c848ee..000000000
--- a/include/meevax/utility/description.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-   Copyright 2018-2022 Tatsuya Yamasaki.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-*/
-
-#ifndef INCLUDED_MEEVAX_UTILITY_DESCRIPTION_HPP
-#define INCLUDED_MEEVAX_UTILITY_DESCRIPTION_HPP
-
-#include <string>
-
-namespace meevax
-{
-inline namespace kernel
-{
-  struct description
-  {
-    std::string const name;
-  };
-} // namespace kernel
-} // namespace meevax
-
-
-#endif // INCLUDED_MEEVAX_UTILITY_DESCRIPTION_HPP
diff --git a/src/kernel/boolean.cpp b/src/kernel/boolean.cpp
index ca7a53f33..73f28c8ee 100644
--- a/src/kernel/boolean.cpp
+++ b/src/kernel/boolean.cpp
@@ -15,7 +15,7 @@
 */
 
 #include <meevax/kernel/boolean.hpp>
-#include <meevax/kernel/equivalence.hpp>
+#include <meevax/kernel/comparator.hpp>
 
 namespace meevax
 {
diff --git a/src/kernel/equivalence.cpp b/src/kernel/comparator.cpp
similarity index 100%
rename from src/kernel/equivalence.cpp
rename to src/kernel/comparator.cpp
diff --git a/src/kernel/complex.cpp b/src/kernel/complex.cpp
index e571547c7..27bda1ace 100644
--- a/src/kernel/complex.cpp
+++ b/src/kernel/complex.cpp
@@ -14,6 +14,8 @@
    limitations under the License.
 */
 
+#include <regex>
+
 #include <meevax/kernel/number.hpp>
 #include <meevax/kernel/reader.hpp>
 
diff --git a/src/kernel/environment.cpp b/src/kernel/environment.cpp
index 8fdc97380..07f0c035c 100644
--- a/src/kernel/environment.cpp
+++ b/src/kernel/environment.cpp
@@ -31,16 +31,14 @@ inline namespace kernel
     define(string_to_symbol(name), value);
   }
 
-  auto environment::evaluate(const_reference expression) -> value_type
+  auto environment::evaluate(const_reference expression) -> value_type try
   {
-    if (expression.is<pair>() and car(expression).is<symbol>()
-                              and car(expression).as<symbol>().value == "define-library")
+    if (car(expression).is<symbol>() and car(expression).as<symbol>().value == "define-library")
     {
       define_library(lexical_cast<std::string>(cadr(expression)), cddr(expression));
       return cadr(expression);
     }
-    else if (expression.is<pair>() and car(expression).is<symbol>()
-                                   and car(expression).as<symbol>().value == "import")
+    else if (car(expression).is<symbol>() and car(expression).as<symbol>().value == "import")
     {
       for (let const& import_set : cdr(expression))
       {
@@ -49,6 +47,10 @@ inline namespace kernel
 
       return unspecified;
     }
+    else if (car(expression).is<symbol>() and car(expression).as<symbol>().value == "declare-raiser")
+    {
+      return raiser = evaluate(cadr(expression));
+    }
     else
     {
       assert(s.is<null>());
@@ -56,9 +58,7 @@ inline namespace kernel
       assert(c.is<null>());
       assert(d.is<null>());
 
-      c = compile(context(), *this, expression, scope());
-
-      c = optimize(c);
+      c = optimize(compile(context(), *this, expression, scope()));
 
       let const result = execute();
 
@@ -70,6 +70,18 @@ inline namespace kernel
       return result;
     }
   }
+  catch (const_reference x)
+  {
+    if (x.is_also<error>())
+    {
+      x.as<error>().raise(); // NOTE: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84476
+      return unit;
+    }
+    else
+    {
+      throw error("uncaught exception", x);
+    }
+  }
 
   auto environment::execute() -> value_type
   {
@@ -207,11 +219,18 @@ inline namespace kernel
     }
     else if (auto iter = libraries.find(lexical_cast<std::string>(declaration)); iter != std::end(libraries))
     {
-      return std::get<1>(*iter).resolve();
+      let const import_set = std::get<1>(*iter).resolve();
+
+      if (auto const& [library_name, library] = *iter; raiser.is<null>() and not library.raiser.is<null>())
+      {
+        raiser = library.raiser;
+      }
+
+      return import_set;
     }
     else
     {
-      throw error(make<string>("No such library"), declaration);
+      throw std::runtime_error("No such library");
     }
   }
 
@@ -223,7 +242,7 @@ inline namespace kernel
 
       if (let const& variable = identity.as<absolute>().symbol(); not eq((*this)[variable], undefined) and not interactive)
       {
-        throw error(make<string>("In a program or library declaration, it is an error to import the same identifier more than once with different bindings"),
+        throw error("In a program or library declaration, it is an error to import the same identifier more than once with different bindings",
                     list(import_set, variable));
       }
       else
@@ -251,7 +270,7 @@ inline namespace kernel
     }
     else
     {
-      throw file_error(make<string>("failed to open file: " + s));
+      throw file_error("failed to open file", make<string>(s));
     }
   }
 
diff --git a/src/kernel/error.cpp b/src/kernel/error.cpp
index 0b7048e10..889b9c4df 100644
--- a/src/kernel/error.cpp
+++ b/src/kernel/error.cpp
@@ -15,11 +15,17 @@
 */
 
 #include <meevax/kernel/error.hpp>
+#include <meevax/kernel/procedure.hpp>
+#include <meevax/kernel/string.hpp>
 
 namespace meevax
 {
 inline namespace kernel
 {
+  error::error(std::string const& message, const_reference irritants)
+    : pair { make<string>(message), irritants }
+  {}
+
   auto error::irritants() const noexcept -> const_reference
   {
     return second;
@@ -60,10 +66,5 @@ inline namespace kernel
 
     return os << magenta(")");
   }
-
-  auto raise(std::string const& message) -> void
-  {
-    throw error(make<string>(message));
-  }
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/instruction.cpp b/src/kernel/instruction.cpp
index 603b36722..cb07bf374 100644
--- a/src/kernel/instruction.cpp
+++ b/src/kernel/instruction.cpp
@@ -64,10 +64,12 @@ inline namespace kernel
       case mnemonic::let_syntax:
       case mnemonic::letrec_syntax:
       case mnemonic::load_absolute:
+      case mnemonic::load_auxiliary:
       case mnemonic::load_constant:
       case mnemonic::load_relative:
       case mnemonic::load_variadic:
       case mnemonic::store_absolute:
+      case mnemonic::store_auxiliary:
       case mnemonic::store_relative:
       case mnemonic::store_variadic:
         os << *iter << " " << *++iter << "\n";
diff --git a/src/kernel/library.cpp b/src/kernel/library.cpp
index f0c5f99b0..b02c96635 100644
--- a/src/kernel/library.cpp
+++ b/src/kernel/library.cpp
@@ -86,18 +86,20 @@ inline namespace kernel
 
     define_library("(meevax context)", [](library & library)
     {
-      library.define<procedure>("emergency-exit", [](let const& xs)
+      library.define<procedure>("emergency-exit", [](let const& xs) -> value_type
       {
-        if (let const& status = car(xs); status.is<bool>())
+        if (let const& status = car(xs); status.is<null>())
         {
-          throw select(status) ? exit_status::success : exit_status::failure;
+          throw success;
+        }
+        else if (status.is<bool>())
+        {
+          throw select(status) ? success : failure;
         }
         else
         {
-          throw exit_status(static_cast<int>(status.as<exact_integer>()));
+          throw static_cast<int>(status.as<exact_integer>());
         }
-
-        return unspecified;
       });
 
       library.export_("emergency-exit");
@@ -148,13 +150,29 @@ inline namespace kernel
       library.export_("%load");
     });
 
-    define_library("(meevax equivalence)", [](library & library)
+    define_library("(meevax dynamic-environment)", [](library & library)
     {
-      library.define<predicate>("eq?",  [](let const& xs) { return eq (car(xs), cadr(xs)); });
-      library.define<predicate>("eqv?", [](let const& xs) { return eqv(car(xs), cadr(xs)); });
+      library.define<syntax>("store-auxiliary", store_auxiliary);
+      library.define<syntax>("load-auxiliary", load_auxiliary);
+
+      library.export_("store-auxiliary");
+      library.export_("load-auxiliary");
+    });
+
+    define_library("(meevax comparator)", [](library & library)
+    {
+      library.define<predicate>("identity=?", [](let const& xs)
+      {
+        return eq(car(xs), cadr(xs));
+      });
+
+      library.define<predicate>("normally=?", [](let const& xs)
+      {
+        return eqv(car(xs), cadr(xs));
+      });
 
-      library.export_("eq?");
-      library.export_("eqv?");
+      library.export_("identity=?");
+      library.export_("normally=?");
     });
 
     define_library("(meevax evaluate)", [](library & library)
@@ -1125,7 +1143,7 @@ inline namespace kernel
 
       library.define<procedure>("vector->string", [](let const& xs)
       {
-        return make<string>(car(xs).as<vector>(),
+        return make<string>(car(xs),
                             cdr(xs).is<pair>() ? cadr(xs) : e0,
                             cddr(xs).is<pair>() ? caddr(xs) : car(xs).as<vector>().length());
       });
@@ -1366,16 +1384,14 @@ inline namespace kernel
 
   auto library::evaluate(const_reference declaration) -> void
   {
-    if (declaration.is<pair>() and car(declaration).is<symbol>()
-                               and car(declaration).as<symbol>().value == "export")
+    if (car(declaration).is<symbol>() and car(declaration).as<symbol>().value == "export")
     {
       for (let const& export_spec : cdr(declaration))
       {
         export_(export_spec);
       }
     }
-    else if (declaration.is<pair>() and car(declaration).is<symbol>()
-                                    and car(declaration).as<symbol>().value == "begin")
+    else if (car(declaration).is<symbol>() and car(declaration).as<symbol>().value == "begin")
     {
       for (let const& command_or_definition : cdr(declaration))
       {
@@ -1404,8 +1420,7 @@ inline namespace kernel
 
     auto resolve = [this](let const& export_spec)
     {
-      if (export_spec.is<pair>() and car(export_spec).is<symbol>()
-                                 and car(export_spec).as<symbol>().value == "rename")
+      if (car(export_spec).is<symbol>() and car(export_spec).as<symbol>().value == "rename")
       {
         return make<absolute>(caddr(export_spec), (*this)[cadr(export_spec)]);
       }
diff --git a/src/kernel/mnemonic.cpp b/src/kernel/mnemonic.cpp
index 485c1c1a3..35175a383 100644
--- a/src/kernel/mnemonic.cpp
+++ b/src/kernel/mnemonic.cpp
@@ -35,6 +35,7 @@ inline namespace kernel
       case mnemonic::letrec:            return os << "letrec";
       case mnemonic::letrec_syntax:     return os << "letrec-syntax";
       case mnemonic::load_absolute:     return os << "load-absolute";
+      case mnemonic::load_auxiliary:    return os << "load-auxiliary";
       case mnemonic::load_closure:      return os << "load-closure";
       case mnemonic::load_constant:     return os << "load-constant";
       case mnemonic::load_continuation: return os << "load-continuation";
@@ -44,6 +45,7 @@ inline namespace kernel
       case mnemonic::select:            return os << "select";
       case mnemonic::stop:              return os << "stop";
       case mnemonic::store_absolute:    return os << "store-absolute";
+      case mnemonic::store_auxiliary:   return os << "store-auxiliary";
       case mnemonic::store_relative:    return os << "store-relative";
       case mnemonic::store_variadic:    return os << "store-variadic";
       case mnemonic::tail_call:         return os << "tail-call";
diff --git a/src/kernel/pair.cpp b/src/kernel/pair.cpp
index d4c801458..9d6328255 100644
--- a/src/kernel/pair.cpp
+++ b/src/kernel/pair.cpp
@@ -22,6 +22,25 @@ inline namespace kernel
 {
   let unit { nullptr };
 
+  pair::pair(const_reference a, const_reference b)
+    : std::pair<value_type, value_type> { a, b }
+  {}
+
+  auto pair::compare(pair const* that) const -> bool
+  {
+    return that and *this == *that;
+  }
+
+  auto pair::type() const noexcept -> std::type_info const&
+  {
+    return typeid(pair);
+  }
+
+  auto pair::write(std::ostream & os) const -> std::ostream &
+  {
+    return os << *this;
+  }
+
   auto operator <<(std::ostream & os, pair const& pare) -> std::ostream &
   {
     os << magenta("(") << car(pare);
diff --git a/src/kernel/port.cpp b/src/kernel/port.cpp
index 47abe9acc..24e0d0ac8 100644
--- a/src/kernel/port.cpp
+++ b/src/kernel/port.cpp
@@ -45,14 +45,19 @@ inline namespace kernel
   #undef DEFINE
 
   #define DEFINE(TYPENAME, FILE_STREAM, NAME)                                  \
-  TYPENAME::TYPENAME(std::string const& name)                                  \
-    : description { name }                                                     \
-    , FILE_STREAM { name }                                                     \
+  TYPENAME::TYPENAME(string const& pathname)                                   \
+    : FILE_STREAM { pathname }                                                 \
+    , pathname { pathname }                                                    \
+  {}                                                                           \
+                                                                               \
+  TYPENAME::TYPENAME(std::string const& pathname)                              \
+    : FILE_STREAM { pathname }                                                 \
+    , pathname { pathname }                                                    \
   {}                                                                           \
                                                                                \
   auto operator <<(std::ostream & os, TYPENAME const& datum) -> std::ostream & \
   {                                                                            \
-    return os << magenta("#,(") << green("open-" NAME) << " " << datum.name << magenta(")"); \
+    return os << magenta("#,(") << green("open-" NAME " ") << datum.pathname << magenta(")"); \
   }                                                                            \
   static_assert(true)
 
diff --git a/src/kernel/procedure.cpp b/src/kernel/procedure.cpp
index 1ff099e2d..b8519a31a 100644
--- a/src/kernel/procedure.cpp
+++ b/src/kernel/procedure.cpp
@@ -22,22 +22,23 @@
 
 #include <meevax/kernel/error.hpp>
 #include <meevax/kernel/procedure.hpp>
+#include <meevax/kernel/string.hpp>
 
 namespace meevax
 {
 inline namespace kernel
 {
-  procedure::procedure(symbol::value_type const& name, function_type const& call)
-    : description { name }
+  procedure::procedure(std::string const& name, function_type const& call)
+    : name { name }
     , call { call }
   {}
 
-  procedure::procedure(symbol::value_type const& name, symbol::value_type const& libfoo_so)
-    : description { name }
+  procedure::procedure(std::string const& name, std::string const& libfoo_so)
+    : name { name }
     , call { dlsym(name, dlopen(libfoo_so)) }
   {}
 
-  auto procedure::dlopen(symbol::value_type const& libfoo_so) -> void *
+  auto procedure::dlopen(std::string const& libfoo_so) -> void *
   {
     auto dlclose = [](void * const handle)
     {
@@ -48,7 +49,7 @@ inline namespace kernel
     };
 
     static std::unordered_map<
-      symbol::value_type, std::unique_ptr<void, decltype(dlclose)>
+      std::string, std::unique_ptr<void, decltype(dlclose)>
     > dynamic_libraries {};
 
     ::dlerror(); // clear
@@ -70,12 +71,12 @@ inline namespace kernel
       }
       else
       {
-        throw file_error(make<string>(::dlerror()), unit);
+        throw file_error(::dlerror());
       }
     }
   }
 
-  auto procedure::dlsym(symbol::value_type const& name, void * const handle) -> function_pointer_type
+  auto procedure::dlsym(std::string const& name, void * const handle) -> function_pointer_type
   {
     if (auto address = ::dlsym(handle, name.c_str()); address)
     {
@@ -83,7 +84,7 @@ inline namespace kernel
     }
     else
     {
-      throw file_error(make<string>(::dlerror()), unit);
+      throw file_error(::dlerror());
     }
   }
 
diff --git a/src/kernel/reader.cpp b/src/kernel/reader.cpp
index 2ebeffbf9..fd90faa01 100644
--- a/src/kernel/reader.cpp
+++ b/src/kernel/reader.cpp
@@ -14,8 +14,11 @@
    limitations under the License.
 */
 
+#include <regex>
+
 #include <meevax/iostream/ignore.hpp>
 #include <meevax/kernel/reader.hpp>
+#include <meevax/kernel/string.hpp>
 
 namespace meevax
 {
@@ -88,7 +91,7 @@ inline namespace kernel
     }
     else
     {
-      throw read_error(make<string>("invalid stream"), unit);
+      throw read_error("An end of file is encountered after the beginning of an object's external representation, but the external representation is incomplete and therefore not parsable");
     }
 
     return codepoint;
@@ -144,7 +147,7 @@ inline namespace kernel
       }
     }
 
-    throw read_error(make<string>("unterminated string"), unit);
+    throw read_error("An end of file is encountered after the beginning of an object's external representation, but the external representation is incomplete and therefore not parsable");
   }
 
   auto get_token(std::istream & is) -> std::string
@@ -190,7 +193,7 @@ inline namespace kernel
       continue;
     }
 
-    throw read_error(make<string>("unterminated multi-line comment"), unit);
+    throw read_error("An end of file is encountered after the beginning of an object's external representation, but the external representation is incomplete and therefore not parsable");
   }
 
   auto read_character_literal(std::istream & is) -> value_type
@@ -233,7 +236,7 @@ inline namespace kernel
           is.putback(*iter);
         }
 
-        throw read_error(make<string>("not a character"), make<string>("\\#" + token));
+        throw read_error("not a character", make<string>("\\#" + token));
       }
     }
   }
diff --git a/src/kernel/string.cpp b/src/kernel/string.cpp
index dd3ecba40..c017245d1 100644
--- a/src/kernel/string.cpp
+++ b/src/kernel/string.cpp
@@ -30,10 +30,10 @@ inline namespace kernel
     for (auto port = std::stringstream(s); not character::is_eof(port.peek()); codepoints.emplace_back(get_codepoint(port)));
   }
 
-  string::string(vector const& v, const_reference begin, const_reference end)
+  string::string(const_reference v, const_reference begin, const_reference end)
   {
-    std::for_each(std::next(std::begin(v.data), begin.as<exact_integer>()),
-                  std::next(std::begin(v.data), end.as<exact_integer>()),
+    std::for_each(std::next(std::begin(v.as<vector>().data), begin.as<exact_integer>()),
+                  std::next(std::begin(v.as<vector>().data), end.as<exact_integer>()),
                   [&](let const& c)
                   {
                     codepoints.push_back(c.as<character>());
diff --git a/src/kernel/syntax.cpp b/src/kernel/syntax.cpp
index 6b9f7a763..57c47dedc 100644
--- a/src/kernel/syntax.cpp
+++ b/src/kernel/syntax.cpp
@@ -21,13 +21,13 @@ namespace meevax
 inline namespace kernel
 {
   syntax::syntax(std::string const& name, function_type const& compile)
-    : description { name }
+    : name { name }
     , compile { compile }
   {}
 
   auto operator <<(std::ostream & os, syntax const& datum) -> std::ostream &
   {
-    return os << magenta("#,(") << green("syntax") << " " << datum.name << magenta(")");
+    return os << magenta("#,(") << green("syntax ") << datum.name << magenta(")");
   }
 } // namespace kernel
 } // namespace meevax
diff --git a/src/kernel/vector.cpp b/src/kernel/vector.cpp
index 5e31ee107..89a9ab8db 100644
--- a/src/kernel/vector.cpp
+++ b/src/kernel/vector.cpp
@@ -18,6 +18,7 @@
 
 #include <meevax/algorithm/for_each.hpp>
 #include <meevax/kernel/error.hpp>
+#include <meevax/kernel/exact_integer.hpp>
 #include <meevax/kernel/string.hpp>
 #include <meevax/kernel/vector.hpp>
 
diff --git a/src/main.cpp b/src/main.cpp
index 89f9d6682..8689bd02b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -14,9 +14,7 @@
    limitations under the License.
 */
 
-#include <meevax/kernel/interaction_environment.hpp>
 #include <meevax/kernel/library.hpp>
-#include <meevax/string/repeat.hpp>
 
 auto main(int const argc, char const* const* const argv) -> int
 {
@@ -48,11 +46,17 @@ auto main(int const argc, char const* const* const argv) -> int
 
     while (main.interactive and main.char_ready())
     {
-      print(u8"\u250c", repeat(u8"\u2500", 79));
-      write(standard_output, u8"\u2502\u03bb> ");
-      print(main.evaluate(main.read()));
+      try
+      {
+        write(standard_output, u8"\u03bb> ");
+        print(main.evaluate(main.read()));
+      }
+      catch (error const& error)
+      {
+        std::cerr << error << std::endl;
+      }
     }
 
-    return underlying_cast(exit_status::success);
+    return success;
   });
 }
diff --git a/test/parameterize.ss b/test/parameterize.ss
new file mode 100644
index 000000000..9663e356d
--- /dev/null
+++ b/test/parameterize.ss
@@ -0,0 +1,118 @@
+; http://blog.practical-scheme.net/shiro/20161215-parameterize
+
+(import (scheme base)
+        (scheme process-context)
+        (scheme write)
+        (srfi 78))
+
+; ------------------------------------------------------------------------------
+
+(define p1 (make-parameter 'default))
+
+(check (procedure? p1) => #t)
+
+(check (parameterize ((p1 'parameterized))
+         (p1)) => parameterized)
+
+(check (p1) => default)
+
+; ------------------------------------------------------------------------------
+
+(define continuation)
+
+(define result)
+
+(parameterize ((p1 'parameterized))
+  (call/cc (lambda (cc)
+             (set! continuation cc)))
+  (set! result (p1)))
+
+(check result => parameterized)
+
+(check (p1) => default)
+
+(continuation)
+
+(check result => parameterized)
+
+(check (p1) => default)
+
+; ------------------------------------------------------------------------------
+
+(parameterize ((p1 'parameterized))
+  (p1 'before-call/cc)
+  (call/cc (lambda (cc)
+             (set! continuation cc)))
+  (set! result (p1)))
+
+(check result => before-call/cc)
+
+(check (p1) => default)
+
+(continuation)
+
+(check result => before-call/cc)
+
+(check (p1) => default)
+
+; ------------------------------------------------------------------------------
+
+(define p2 (make-parameter 1))
+
+(parameterize ((p2 3))
+  (set! p2 string->number))
+
+; ------------------------------------------------------------------------------
+
+(define p3 (make-parameter 1 -))
+
+(check (p3) => -1)
+
+(check (parameterize ((p3 -5))
+         (p3)) => 5)
+
+(parameterize ((p3 -5))
+  (call/cc (lambda (cc)
+             (set! continuation cc)))
+  (set! result (p3)))
+
+(check result => 5)
+
+(check (p3) => -1)
+
+(continuation)
+
+(check result => 5)
+
+(check (p3) => -1)
+
+; ------------------------------------------------------------------------------
+
+(define a (make-parameter 1 (lambda (x)
+                              (unless (number? x)
+                                (error "!!"))
+                              x)))
+
+(define b (make-parameter 2 (lambda (x)
+                              (unless (number? x)
+                                (error "!!"))
+                              x)))
+
+(check (call/cc (lambda (return)
+                  (with-exception-handler
+                    (lambda (x)
+                      (return 'error-raised))
+                    (lambda ()
+                      (parameterize ((a 10)
+                                     (b 'hoge))
+                        (list a b)))))) => error-raised)
+
+(check (a) => 1)
+
+(check (b) => 2)
+
+; ------------------------------------------------------------------------------
+
+(check-report)
+
+(exit (check-passed? 20))
diff --git a/test/with-exception-handler.ss b/test/with-exception-handler.ss
new file mode 100644
index 000000000..93cbab44c
--- /dev/null
+++ b/test/with-exception-handler.ss
@@ -0,0 +1,54 @@
+(import (scheme base)
+        (scheme eval)
+        (scheme process-context)
+        (scheme write)
+        (srfi 78))
+
+(check (call/cc (lambda (return)
+                  (with-exception-handler
+                    (lambda (x)
+                      (return "addition aborted"))
+                    (lambda ()
+                      (+ 1 "2" 3))))) => "addition aborted")
+
+(check (call/cc (lambda (return)
+                  (with-exception-handler
+                    (lambda (x)
+                      (return "addition aborted"))
+                    (lambda ()
+                      (eval '(+ 1 "2" 3)
+                            (environment '(scheme base))))))) => "addition aborted")
+
+(check (call/cc (lambda (return)
+                  (with-exception-handler
+                    (lambda (x)
+                      (return "addition aborted 1"))
+                    (lambda ()
+                      (eval '(call/cc (lambda (return)
+                                        (with-exception-handler
+                                          (lambda (e)
+                                            (return "addition aborted 2"))
+                                          (lambda ()
+                                            (+ 1 "2" 3)))))
+                            (environment '(scheme base))))))) => "addition aborted 2")
+
+(check (call/cc (lambda (return)
+                  (with-exception-handler
+                    (lambda (x)
+                      (display "receive!")
+                      (newline)
+                      (return "addition aborted 1"))
+                    (lambda ()
+                      (eval '(call/cc (lambda (return)
+                                        (with-exception-handler
+                                          (lambda (e)
+                                            (display "receive, but ignore!")
+                                            (newline))
+                                          (lambda ()
+                                            (+ 1 "2" 3)))))
+                            (environment '(scheme base)
+                                         '(scheme write))))))) => "addition aborted 1")
+
+(check-report)
+
+(exit (check-passed? 4))