Merge pull request #5084 from mruby/mruby3

Mruby3

164 files changed, 9462 insertions, 7851 deletions

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 335c0cdf6..95f7c40d8 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -6,73 +6,67 @@ jobs:
   Ubuntu-1604:
     runs-on: ubuntu-16.04
     env:
-      MRUBY_CONFIG: travis_config.rb
+      MRUBY_TARGET: travis
     steps:
     - uses: actions/checkout@v1
     - name: apt
       run: sudo apt install ruby gperf
-    - name: build
-      run: rake -m
-    - name: test
-      run: rake test
+    - name: build and test
+      run: rake -m -j4 gensym all test
 
   Ubuntu-1804-gcc:
     runs-on: ubuntu-18.04
     env:
-      MRUBY_CONFIG: travis_config.rb
+      MRUBY_TARGET: travis
       CC: gcc
       CXX: g++
     steps:
     - uses: actions/checkout@v1
     - name: apt
       run: sudo apt install ruby gperf gcc g++
-    - name: build
-      run: rake -m
-    - name: test
-      run: rake test
+    - name: build and test
+      run: rake -m -j4 gensym all test
 
   Ubuntu-1804-clang:
     runs-on: ubuntu-18.04
     env:
-      MRUBY_CONFIG: travis_config.rb
+      MRUBY_TARGET: travis
       CC: clang
       CXX: clang++
     steps:
     - uses: actions/checkout@v1
     - name: apt
       run: sudo apt install ruby gperf
-    - name: build
-      run: rake -m
-    - name: test
-      run: rake test
+    - name: build and test
+      run: rake -m -j4 gensym all test
 
   macOS:
     runs-on: macos-latest
     env:
-      MRUBY_CONFIG: travis_config.rb
+      MRUBY_TARGET: travis
     steps:
     - uses: actions/checkout@v1
     - name: brew
       run: brew install ruby gperf
-    - name: build
-      run: rake -m
-    - name: test
-      run: rake test
+    - name: build and test
+      run: rake -m -j4 gensym all test
 
   Windows-MinGW:
     runs-on: windows-latest
+    env:
+      MRUBY_TARGET: travis
+      CFLAGS: -g -O1 -Wall -Wundef
     steps:
     - uses: actions/checkout@v1
     - name: chocolatey
       run: choco install -y ruby gperf
     - name: build
-      run: rake -E 'STDOUT.sync=true' test
-      env:
-        MRUBY_CONFIG: travis_config.rb
-        CFLAGS: -g -O1 -Wall -Wundef
+      run: rake -E 'STDOUT.sync=true' -j4 gensym all test
 
   Windows-Cygwin:
     runs-on: windows-latest
+    env:
+      MRUBY_TARGET: travis
     steps:
     - uses: actions/checkout@v1
     - uses: actions/cache@v1
@@ -90,13 +84,23 @@ jobs:
     - name: Set ENV
       run: |
         echo '::set-env name=PATH::C:\tools\cygwin\bin;C:\tools\cygwin\usr\bin'
-    - name: build
+    - name: build and test
       shell: cmd
-      run: C:\tools\cygwin\bin\ruby.exe /usr/bin/rake -E 'STDOUT.sync=true' -m
-      env:
-        MRUBY_CONFIG: travis_config.rb
-    - name: test
+      run: C:\tools\cygwin\bin\ruby.exe /usr/bin/rake -E 'STDOUT.sync=true' -m gensym all test
+
+  Windows-VC:
+    runs-on: windows-latest
+    env:
+      MRUBY_TARGET: appveyor
+      # TODO(take-cheeze): Re-enable /O2
+      CFLAGS: "/c /nologo /W3 /we4013 /Zi /MD /D_CRT_SECURE_NO_WARNINGS"
+      CXXFLAGS: "/c /nologo /W3 /Zi /MD /EHs /D_CRT_SECURE_NO_WARNINGS"
+    steps:
+    - uses: actions/checkout@v1
+    - name: chocolatey
+      run: choco install -y ruby gperf
+    - name: build and test
       shell: cmd
-      run: C:\tools\cygwin\bin\ruby.exe /usr/bin/rake -E 'STDOUT.sync=true' test
-      env:
-        MRUBY_CONFIG: travis_config.rb
+      run: |
+        call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+        rake -E "STDOUT.sync=true" gensym all test
diff --git a/.travis.yml b/.travis.yml
index f04132d07..676ac27b5 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,9 +3,12 @@ language: c
 jobs:
   - os: linux
   - os: osx
+    before_install:
+      - HOMEBREW_NO_AUTO_UPDATE=1 HOMEBREW_NO_INSTALL_CLEANUP=1 brew install bison
+      - export PATH="/usr/local/opt/bison/bin:$PATH"
 
 env:
-  - MRUBY_CONFIG=travis_config.rb
+  - MRUBY_TARGET=travis
 
 script:
-  - rake -m && rake test
+  - rake gensym && rake -m && rake test
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0b632f51c..ec25f89b1 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -56,7 +56,7 @@ on-demand.
 
 Use C++ style comments only for temporary comment e.g. commenting out some code lines.
 
-#### Insert a break after the method return value:
+#### Insert a break after the function return value:
 
     int
     main(void)
@@ -72,4 +72,5 @@ language itself. Please note the following hints for your Ruby code:
 #### Comply with the Ruby standard (ISO/IEC 30170:2012)
 
 mruby is currently targeting to execute Ruby code which complies to ISO/IEC
-30170:2012 (http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579).
+30170:2012 (http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579),
+unless there's a clear reason, e.g. the latest Ruby has changed behavior from ISO.
diff --git a/README.md b/README.md
index 5bea9d442..f7db82375 100644
--- a/README.md
+++ b/README.md
@@ -40,11 +40,13 @@ We don't have a mailing list, but you can use [GitHub issues](https://github.com
 
 See the [compile.md](https://github.com/mruby/mruby/blob/master/doc/guides/compile.md) file.
 
-## Running Tests
+## How to Build
 
-To run the tests, execute the following from the project's root directory.
+To build mruby, execute the following from the project's root directory.
 
-    $ rake test
+  $ rake TARGET=<target> test
+
+The default `TARGET` is `host`. `TARGET` will be loaded from `target` directory.
 
 Note: `bison` bundled with MacOS is too old to compile `mruby`.
 Try `brew install bison` and follow the instuction shown to update
diff --git a/Rakefile b/Rakefile
index 4115d9e8e..5c5a6e8eb 100644
--- a/Rakefile
+++ b/Rakefile
@@ -14,7 +14,13 @@ require "mruby-core-ext"
 require "mruby/build"
 
 # load configuration file
-MRUBY_CONFIG = (ENV['MRUBY_CONFIG'] && ENV['MRUBY_CONFIG'] != '') ? ENV['MRUBY_CONFIG'] : "#{MRUBY_ROOT}/build_config.rb"
+if ENV['MRUBY_CONFIG']
+  MRUBY_CONFIG = ENV['MRUBY_CONFIG']
+  MRUBY_TARGET = File.basename(MRUBY_CONFIG, ".rb")
+else
+  MRUBY_TARGET = ENV['MRUBY_TARGET'] || ENV['TARGET'] || "host"
+  MRUBY_CONFIG = "#{MRUBY_ROOT}/target/#{MRUBY_TARGET}.rb"
+end
 load MRUBY_CONFIG
 
 # load basic rules
@@ -46,15 +52,19 @@ task :default => :all
 
 bin_path = ENV['INSTALL_DIR'] || "#{MRUBY_ROOT}/bin"
 
-depfiles = MRuby.targets['host'].bins.map do |bin|
-  install_path = MRuby.targets['host'].exefile("#{bin_path}/#{bin}")
-  source_path = MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/#{bin}")
+if MRuby.targets['host']
+  target = MRuby.targets['host']
+  depfiles = target.bins.map do |bin|
+    install_path = target.exefile("#{bin_path}/#{bin}")
+    source_path = target.exefile("#{target.build_dir}/bin/#{bin}")
 
-  file install_path => source_path do |t|
-    install_D t.prerequisites.first, t.name
+    file install_path => source_path do |t|
+      install_D t.prerequisites.first, t.name
+    end
+    install_path
   end
-
-  install_path
+else
+  depfiles = []
 end
 
 MRuby.each_target do |target|
@@ -87,15 +97,6 @@ MRuby.each_target do |target|
           install_D t.prerequisites.first, t.name
         end
         depfiles += [ install_path ]
-      elsif target == MRuby.targets['host-debug']
-        unless MRuby.targets['host'].gems.map {|g| g.bins}.include?([bin])
-          install_path = MRuby.targets['host-debug'].exefile("#{bin_path}/#{bin}")
-
-          file install_path => exec do |t|
-            install_D t.prerequisites.first, t.name
-          end
-          depfiles += [ install_path ]
-        end
       else
         depfiles += [ exec ]
       end
@@ -103,6 +104,143 @@ MRuby.each_target do |target|
   end
 end
 
+mkdir_p "#{MRUBY_ROOT}/build"
+cfiles = (
+  Dir.glob("#{MRUBY_ROOT}/src/*.c")+
+  Dir.glob("#{MRUBY_ROOT}/mrbgems/**/*.c")+
+  Dir.glob("#{MRUBY_ROOT}/build/repos/**/{src,core}/*.c")
+).uniq
+rbfiles = (
+  Dir.glob("#{MRUBY_ROOT}/mrblib/**/*.rb")+
+  Dir.glob("#{MRUBY_ROOT}/mrbgems/*/mrblib/**/*.rb")+
+  Dir.glob("#{MRUBY_ROOT}/build/repos/**/mrblib/**/*.rb")
+).uniq
+psfiles = Dir.glob("#{MRUBY_ROOT}/{mrblib,mrbgems,build/repos}/**/presym")
+symbols = []
+psfiles.each do |file|
+  symbols += File.readlines(file).grep_v(/^# /)
+end
+symbols.each{|x| x.chomp!}
+presym_file="#{MRUBY_ROOT}/build/presym"
+op_table = {
+  "!" => "not",
+  "!=" => "neq",
+  "!~" => "nmatch",
+  "%" => "mod",
+  "&" => "and",
+  "&&" => "andand",
+  "*" => "mul",
+  "**" => "pow",
+  "+" => "add",
+  "+@" => "plus",
+  "-" => "sub",
+  "-@" => "minus",
+  "/" => "div",
+  "<" => "lt",
+  "<=" => "le",
+  "<<" => "lshift",
+  "<=>" => "cmp",
+  "==" => "eq",
+  "===" => "eqq",
+  "=~" => "match",
+  ">" => "gt",
+  ">=" => "ge",
+  ">>" => "rshift",
+  "[]" => "aref",
+  "[]=" => "aset",
+  "^" => "xor",
+  "`" => "tick",
+  "|" => "or",
+  "||" => "oror",
+  "~" => "neg",
+}
+
+file presym_file => cfiles+rbfiles+psfiles+[__FILE__] do
+  csymbols = cfiles.map do |f|
+    src = File.read(f)
+    src.gsub!(/\/\/.+(\n|$)/, "\n")
+    [src.scan(/intern_lit\([^\n"]*"([^\n "]*)"/),
+     src.scan(/mrb_define_method\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_class_method\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_class\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_module\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_module_function\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_const\([^\n"]*"([^\n"]*)"/),
+     src.scan(/mrb_define_global_const\([^\n"]*"([^\n"]*)"/),
+     src.scan(/MRB_SYM\((\w+)\)/),
+     src.scan(/MRB_QSYM\((\w+)\)/).map{|x,|
+       x.sub!(/_p$/, "?") || x.sub!(/_b$/, "!") || x.sub!(/_e$/, "=") || x.sub!(/^0_/, "@")  || x.sub!(/^00_/, "@@")
+     }.compact]
+  end
+  rbsymbols = rbfiles.map do |f|
+    src = File.read(f)
+    src.force_encoding(Encoding::BINARY)
+    [src.scan(/\bclass +([A-Z]\w*)/),
+     src.scan(/\bmodule +([A-Z]\w*)/),
+     src.scan(/\bdef +(\w+[!?=]?)/),
+     src.scan(/\balias +(\w+[!?]?)/),
+     src.scan(/\b([A-Z]\w*) *=[^=]/),
+     src.scan(/(\$[a-zA-Z_]\w*)/),
+     src.scan(/(\$[$!?0-9]\w*)/),
+     src.scan(/(@@?[a-zA-Z_]\w*)/),
+     src.scan(/[^.]\.([a-zA-Z_]\w*[!?]?)/),
+     src.scan(/\.([a-zA-Z_]\w* *=)/).map{|x|x.map{|s|s.gsub(' ', '')}},
+     src.scan(/\b([a-zA-Z_]\w*):/),
+     src.scan(/:([a-zA-Z_]\w*[!?=]?)/),
+     src.scan(/[\(\[\{ ]:"([^"]+)"/).map{|x|x.map{|s|s.gsub('\#', '#')}},
+     src.scan(/[ \(\[\{]:'([^']+)'/)
+    ]
+  end
+  symbols = (symbols+csymbols+rbsymbols+op_table.keys).flatten.compact.uniq.sort.map{|x| x.gsub("\n", '\n')}
+  presyms = File.readlines(presym_file) rescue []
+  presyms.each{|x| x.chomp!}
+  if presyms != symbols
+    File.write(presym_file, symbols.join("\n"))
+  end
+end
+
+presym_inc=presym_file+".inc"
+file presym_inc => presym_file do
+  presyms = File.readlines(presym_file)
+  presyms.each{|x| x.chomp!}
+  File.open(presym_inc, "w") do |f|
+    f.print "/* MRB_PRESYM_CSYM(sym, num) - symbol which is valid C id name */\n"
+    f.print "/* MRB_PRESYM_QSYM(name, sym, num) - symbol with alias name */\n"
+    f.print "/* MRB_PRESYM_SYM(name, num) - symbol which is not valid C id */\n"
+    presyms.each.with_index do |sym,i|
+      if sym.bytes.detect{|x|x>0x80} || /\A\$/ =~ sym
+        f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n"
+      elsif /\A\w+\Z/ =~ sym
+        f.print "MRB_PRESYM_CSYM(#{sym}, #{i+1})\n"
+      elsif op_table.key?(sym)
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{op_table[sym]}, #{i+1})\n"
+      elsif /\A[A-Za-z_]\w*\?\Z/ =~ sym
+        s = sym.dup; s[-1] = "_p"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      elsif /\A[A-Za-z_]\w*\!\Z/ =~ sym
+        s = sym.dup; s[-1] = "_b"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      elsif /\A[A-Za-z_]\w*\=\Z/ =~ sym
+        s = sym.dup; s[-1] = "_e"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      elsif /\A@@/ =~ sym
+        s = sym.dup; s[0,2] = "00_"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      elsif /\A@/ =~ sym
+        s = sym.dup; s[0] = "0_"
+        f.print "MRB_PRESYM_QSYM(\"#{sym}\", #{s}, #{i+1})\n"
+      else
+        f.print "MRB_PRESYM_SYM(\"#{sym}\", #{i+1})\n"
+      end
+    end
+    f.print "#define MRB_PRESYM_MAX #{presyms.size}"
+  end
+end
+
+desc "preallocated symbols"
+task :gensym => presym_inc
+task :all => :gensym
+
 depfiles += MRuby.targets.map { |n, t|
   t.libraries
 }.flatten
@@ -156,5 +294,7 @@ task :deep_clean => ["clean", "clean_doc"] do
   MRuby.each_target do |t|
     rm_rf t.gem_clone_dir
   end
+  rm_f presym_file
+  rm_f presym_inc
   puts "Cleaned up mrbgems build folder"
 end
diff --git a/appveyor.yml b/appveyor.yml
index e963ea035..e2fa0e900 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -38,7 +38,9 @@ init:
   - set PATH=C:\Ruby26-x64\bin;%PATH%
   - ruby --version
 
+
 build_script:
-  - set MRUBY_CONFIG=appveyor_config.rb
-  - rake -m -j4
-  - rake -E STDOUT.sync=true test
+  - set MRUBY_TARGET=appveyor
+  - rake gensym
+  - rake -m all
+  - rake -E $stdout.sync=true test
diff --git a/appveyor_config.rb b/appveyor_config.rb
deleted file mode 100644
index 25745daa8..000000000
--- a/appveyor_config.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-def setup_option(conf)
-  conf.cc.flags[0].delete("/Zi") unless ENV['CFLAGS']
-  conf.cxx.flags[0].delete("/Zi") unless ENV['CFLAGS'] || ENV['CXXFLAGS']
-  conf.linker.flags << "/DEBUG:NONE" unless ENV['LDFLAGS']
-end
-
-MRuby::Build.new('full-debug') do |conf|
-  toolchain :visualcpp
-  enable_debug
-
-  # include all core GEMs
-  conf.gembox 'full-core'
-  conf.cc.defines += %w(MRB_GC_STRESS MRB_METHOD_CACHE MRB_ENABLE_DEBUG_HOOK)
-  setup_option(conf)
-
-  conf.enable_test
-end
-
-MRuby::Build.new do |conf|
-  toolchain :visualcpp
-
-  # include all core GEMs
-  conf.gembox 'full-core'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_FIXED_ARENA)
-  end
-  setup_option(conf)
-  conf.enable_bintest
-  conf.enable_test
-end
-
-MRuby::Build.new('cxx_abi') do |conf|
-  toolchain :visualcpp
-
-  conf.gembox 'full-core'
-  conf.compilers.each do |c|
-    c.defines += %w(MRB_GC_FIXED_ARENA)
-  end
-  setup_option(conf)
-  conf.enable_bintest
-  conf.enable_test
-
-  enable_cxx_abi
-
-  build_mrbc_exec
-end
diff --git a/doc/guides/compile.md b/doc/guides/compile.md
index d7937bb2e..233c3e594 100644
--- a/doc/guides/compile.md
+++ b/doc/guides/compile.md
@@ -14,37 +14,53 @@ To compile mruby out of the source code you need the following tools:
 
 Note that `bison` bundled with MacOS is too old to compile `mruby`.
 Try `brew install bison` and follow the instuction shown to update
-the `$PATH` to compile `mruby`.
+the `$PATH` to compile `mruby`. We also encourage to upgrade `ruby`
+on MacOS in similar manner.
 
 Optional:
-* GIT (to update mruby source and integrate mrbgems easier)
+* git (to update mruby source and integrate mrbgems easier)
 * C++ compiler (to use GEMs which include \*.cpp, \*.cxx, \*.cc)
 * Assembler (to use GEMs which include \*.asm)
 
-## Usage
+## Build
+
+To compile `mruby`, just call `rake` inside of the mruby source
+root. To generate and execute the test tools call `rake test`. To
+clean all build files call `rake clean`. To see full command line on
+build, call `rake -v`.
+
+If you want to compile for the specific configuration, specify
+`MRUBY_TARGET` or `TARGET` environment variable, e.g
+
+```sh
+rake TAGRET=host
+```
+
+The default target is `host`.  The compilation target desciption files
+(with `.rb` suffix) are contained in the `target` directory.
+
+A build description file contains the build configuration of mruby and
+looks like the following for example:
 
-Inside of the root directory of the mruby source a file exists
-called *build_config.rb*. This file contains the build configuration
-of mruby and looks like this for example:
 ```ruby
 MRuby::Build.new do |conf|
   toolchain :gcc
 end
 ```
 
-All tools necessary to compile mruby can be set or modified here. In case
-you want to maintain an additional *build_config.rb* you can define a
-customized path using the *$MRUBY_CONFIG* environment variable.
-
-To compile just call `rake` inside of the mruby source root. To
-generate and execute the test tools call `rake test`. To clean
-all build files call `rake clean`. To see full command line on
-build, call `rake -v`.
+All tools necessary to compile mruby can be set or modified here. In
+case you want to try different configuration, you can create a new
+configuration file under `target` and specify the configuration using
+the `MRUBY_TARGET` environment variable.
 
 ## Build Configuration
 
-Inside of the *build_config.rb* the following options can be configured
-based on your environment.
+To create a new configuration, copy the existing configuration in the
+`target` directory, and modify it. We wish you submit a pull-request,
+once you created a new configuration for a new platform.
+
+Inside of the configuration file, the following options can be
+configured based on your environment.
 
 ### Toolchains
 
@@ -88,15 +104,12 @@ in `ANDROID_STANDALONE_TOOLCHAIN`.
 ### Binaries
 
 It is possible to select which tools should be compiled during the compilation
-process. The following tools can be selected:
-* mruby (mruby interpreter)
-* mirb (mruby interactive shell)
+process. For example, 
 
-To select them declare conf.gem as follows:
-```ruby
-conf.gem "#{root}/mrbgems/mruby-bin-mruby"
-conf.gem "#{root}/mrbgems/mruby-bin-mirb"
-```
+* `mruby`
+* `mirb`
+
+The configuration are done via `mrbgems`. See `Mrbgems` section.
 
 ### File Separator
 
@@ -209,17 +222,33 @@ end
 
 ### Mrbgems
 
-Integrate GEMs in the build process.
+`mruby` comes with the (sort of) packaging system named `mrbgems`. To
+specify `gem`, you can use `conf.gem` in the configuration file.
+
 ```ruby
-# Integrate GEM with additional configuration
-conf.gem 'path/to/gem' do |g|
-  g.cc.flags << ...
-end
+# Integrate a bundled Gem you see in `mrbgems` directory
+conf.gem :core => 'mruby-something'
+
+# Integrate a Gem from GitHub
+conf.gem :github => 'someone/mruby-another'
 
-# Integrate GEM without additional configuration
-conf.gem 'path/to/another/gem'
+# Integrate a mruby binary Gem
+conf.gem :core => 'mruby-bin-mruby'
+
+# Integrate a interactive mruby binary Gem
+conf.gem :core => 'mruby-bin-mirb'
+
+# Integrate GemBox (set of Gems)
+conf.gembox "default"
 ```
 
+A GemBox is a set of Gems defined in `mrbgems/default.gembox` for example.
+It's just a set of `mrbgem` configurations.
+
+There is a `RubyGem` (gem for CRuby) named `mgem` that help you to
+manage `mrbgems`. Try `gem install mgem`. `mgem` can show you the list
+of registered `mrbgems`.
+
 See doc/mrbgems/README.md for more option about mrbgems.
 
 ### Mrbtest
@@ -327,6 +356,10 @@ root directory. The structure of this directory will look like this:
 
 	+- build
 	   |
+	   +-  presym         <- List of preallocated symbolx
+       |
+	   +-  presym.inc     <- C source file for preallocated symbols
+       |
 	   +-  host
 	       |
 	       +- bin          <- Binaries (mirb, mrbc and mruby)
@@ -379,6 +412,10 @@ like this:
 
 	+- build
 	   |
+	   +-  presym         <- List of preallocated symbolx
+       |
+	   +-  presym.inc     <- C source file for preallocated symbols
+	   |
 	   +-  host
 	   |   |
 	   |   +- bin           <- Native Binaries
diff --git a/doc/guides/mrbconf.md b/doc/guides/mrbconf.md
index 1e1a5afcf..c95634604 100644
--- a/doc/guides/mrbconf.md
+++ b/doc/guides/mrbconf.md
@@ -46,11 +46,11 @@ You can use mrbconfs with following ways:
 
 ## Primitive type configuration.
 
-`MRB_USE_FLOAT`
+`MRB_USE_FLOAT32`
 * When defined single precision floating point type(C type `float`) is used as `mrb_float`.
-* Else double precision floating point type(C type `double`) is used as `mrb_float`.
+* Otherwise double precision floating point type(C type `double`) is used as `mrb_float`.
 
-`MRB_WITHOUT_FLOAT`
+`MRB_NO_FLOAT`
 * When defined removes floating point numbers from mruby.
 * It makes mruby easier to handle in "Microcontroller without FPU" and "Kernel Space".
 
@@ -117,7 +117,7 @@ largest value of required alignment.
 
 `MRB_NAN_BOXING`
 * If defined represent `mrb_value` in boxed `double`.
-* Conflicts with `MRB_USE_FLOAT` and `MRB_WITHOUT_FLOAT`.
+* Conflicts with `MRB_USE_FLOAT32` and `MRB_NO_FLOAT`.
 
 `MRB_WORD_BOXING`
 * If defined represent `mrb_value` as a word.
@@ -163,17 +163,17 @@ largest value of required alignment.
 * Default value is `128`.
 * Specifies initial capacity of `RString` created by `mrb_str_buf_new` function..
 
-`MRB_METHOD_CACHE`
-* Improve performance for method dispatch.
+`MRB_NO_METHOD_CACHE`
+* Disable method cache to save memory.
 
 `MRB_METHOD_CACHE_SIZE`
-* Default value is `128`.
-* Ignored if `MRB_METHOD_CACHE` is not defined.
+* Default value is `256`.
+* Ignored if `MRB_NO_METHOD_CACHE` is defined.
 * Need to be the power of 2.
 
-`MRB_METHOD_T_STRUCT`
+`MRB_USE_METHOD_T_STRUCT`
 * Use C struct to represent `mrb_method_t`
-* No `MRB_METHOD_T_STRUCT` requires highest 2 bits of function pointers to be zero
+* No `MRB_USE_METHOD_T_STRUCT` requires highest 2 bits of function pointers to be zero
 * Define this macro on machines that use higher bits of pointers
 
 `MRB_ENABLE_ALL_SYMBOLS`
diff --git a/doc/limitations.md b/doc/limitations.md
index 770daa7a4..8ac959b98 100644
--- a/doc/limitations.md
+++ b/doc/limitations.md
@@ -17,7 +17,7 @@ Please help to improve it by submitting your findings.
 ## `1/2` gives `0.5`
 
 Since mruby does not have `Bignum`, bigger integers are represented
-by `Float` numbers. To enhance interoperability between `Fixnum`
+by `Float` numbers. To enhance interoperability between `Integer`
 and `Float`, mruby provides `Float#upto` and other iterating
 methods for the `Float` class.  As a side effect, `1/2` gives `0.5`
 not `0`.
@@ -63,8 +63,15 @@ end
 
 #### mruby [2.1.2 (2020-08-06)]
 
-No exception is raised.
+No exception is raised. Instead you have to do:
 
+```ruby
+begin
+  1 / 0
+rescue => e
+  raise e
+end
+```
 ## Fiber execution can't cross C function boundary
 
 mruby's `Fiber` is implemented in a similar way to Lua's co-routine. This
@@ -245,8 +252,7 @@ trace (most recent call last):
 ## Keyword arguments
 
 mruby keyword arguments behave slightly different from CRuby 2.5
-to make the behavior simpler and less confusing. Maybe in the
-future, the simpler behavior will be adopted to CRuby as well.
+to make the behavior simpler and less confusing. 
 
 #### Ruby [ruby 2.5.1p57 (2018-03-29 revision 63029)]
 
@@ -264,6 +270,20 @@ trace (most recent call last):
 -e:1: keyword argument hash with non symbol keys (ArgumentError)
 ```
 
+## `nil?` redefinition in conditional expressions
+
+Redefinition of `nil?` is ignored in conditional expressions.
+
+```ruby
+a = "a"
+def a.nil?
+  true
+end
+puts(a.nil? ? "truthy" : "falsy")
+```
+
+Ruby outputs `falsy`. mruby outputs `truthy`.
+
 ## Argument Destructuring
 
 ```ruby
@@ -283,17 +303,3 @@ f(1,[2,3])
 ```
 
 CRuby gives `[1,2,3,nil]`. mruby raises `NoMethodError` for `b`.
-
-## `nil?` redefinition in conditional expressions
-
-Redefinition of `nil?` is ignored in conditional expressions.
-
-```ruby
-a = "a"
-def a.nil?
-  true
-end
-puts(a.nil? ? "truthy" : "falsy")
-```
-
-Ruby outputs `falsy`. mruby outputs `truthy`.
diff --git a/doc/mruby3.md b/doc/mruby3.md
new file mode 100644
index 000000000..4e4f94d07
--- /dev/null
+++ b/doc/mruby3.md
@@ -0,0 +1,108 @@
+User visible changes in `mruby3`
+===
+
+# Build System
+
+You can specify `TARGET` option to `rake` via a command line
+option, or via an environment variable, e.g.
+
+`rake TARGET=host all`
+
+or
+
+`TARGET=host rake all`
+
+It's much easier to switch multiple targets than the
+previous `build_config.rb` system.
+
+## `presym` target
+
+The first compilation of `mruby` may require generation of a
+static symbol table named `build/presym`. You can generate
+the table by `rake gensym`.
+
+## `target` directory
+
+Build target specification files are loaded from `target`
+directory. The default `TARGET` is `host` which is described
+in `target/host.rb`. There are many other targets for example:
+
+* `host-gprof`: compiles with `gprof` for performance tuning
+* `host-m32`: compiles in gcc 32bit mode on 64bit platforms
+* `boxing`: compiles all three boxing options
+* `clang-asan`: compiles with `clang`'s Address Sanitizer
+
+`target/host.rb` comes  with comments to help  writing a new
+target description.
+
+If you want to have your target description out of the
+source tree, you can specify the path to the description
+file in `MRUBY_CONFIG`.
+
+# Build Target Contribution
+
+When you write a new target description, please
+contribute. We welcome your contribution as a GitHub
+pull-request.
+
+# Languge Changes
+
+## New Syntax
+
+We have ported some new syntax from CRuby.
+
+* R-assignment (`12 => x`)
+* Numbered block parameter (`x.map{_1 * 2}`)
+* End-less `def` (`def double(x) = x*2`)
+
+# Configuration Options Changed
+
+Some configuration macro names are changed for consistency
+
+## `MRB_NO_FLOAT`
+
+Changed from `MRB_WITHOUT_FLOAT` to conform `USE_XXX` naming
+convention.
+
+## `MRB_USE_FLOAT32`
+
+Changed from `MRB_USE_FLOAT` to make sure `float` here means
+using single precision float, and not the opposite of
+`MRB_NO_FLOAT`.
+
+## `MRB_USE_METHOD_T_STRUCT`
+
+Changed from `MRB_METHOD_T_STRUCT`.
+
+To use `struct` version of `mrb_method_t`. More portable but consumes more memory.
+Turned on by default on 32bit platforms.
+
+## `MRB_NO_BOXING`
+
+Uses `struct` to represent `mrb_value`. Consumes more memory
+but easier to inveticate the internal and to debug. It used
+to be default `mrb_value` representation. Now the default is
+`MRB_WORD_BOXING`.
+
+## `MRB_WORD_BOXING`
+
+Pack `mrb_value` in an `intptr_t` integer. Consumes less
+memory compared to `MRB_NO_BOXING` especially on 32 bit
+platforms. `Fixnum` size is 31 bits so some integer values
+does not fit in `Fixnum` integers.
+
+## `MRB_NAN_BOXING`
+
+Pack `mrb_value` in a floating pointer number. Nothing
+changed from previous versions.
+
+## `MRB_USE_MALLOC_TRIM`
+
+Call `malloc_trim(0)` from mrb_full_gc() if this macro is defined.
+If you are using glibc malloc, this macro could reduce memory consumption.
+
+# Internal Changes
+
+## `Random` now use `xoshiro128++`.
+
+For better and faster random number generation.
diff --git a/doc/opcode.md b/doc/opcode.md
index a79453e8a..513b28302 100644
--- a/doc/opcode.md
+++ b/doc/opcode.md
@@ -20,121 +20,107 @@ sign) of operands.
 * sS: signed 16bit
 * W: 24bit
 
-First two byte operands may be extended to 16bit. When those byte
-operands are bigger than 256, the instruction will be prefixed by
-`OP_EXT1` (means 1st operand is 16bit) or `OP_EXT2` (means 2nd operand
-is 16bit) or `OP_EXT3` (means 1st and 2nd operands are 16bit).
-
-For instructions marked by `'`, `OP_EXT1` can be prefixed. For those
-with `"`, either `OP_EXT1` or `OP_EXT2` or `OP_EXT2` can be prefixed.
-
 ## table.1 Instruction Table
 
 | Instruction Name | Operand type | Semantics                                              |
 |------------------|--------------|--------------------------------------------------------|
 | OP_NOP           | -            | no operation                                           |
-| OP_MOVE"         | BB           | R(a) = R(b)                                            |
-| OP_LOADL"        | BB           | R(a) = Pool(b)                                         |
-| OP_LOADI"        | BB           | R(a) = mrb_int(b)                                      |
-| OP_LOADINEG"     | BB           | R(a) = mrb_int(-b)                                     |
-| OP_LOADI__1'     | B            | R(a) = mrb_int(-1)                                     |
-| OP_LOADI_0'      | B            | R(a) = mrb_int(0)                                      |
-| OP_LOADI_1'      | B            | R(a) = mrb_int(1)                                      |
-| OP_LOADI_2'      | B            | R(a) = mrb_int(2)                                      |
-| OP_LOADI_3'      | B            | R(a) = mrb_int(3)                                      |
-| OP_LOADI_4'      | B            | R(a) = mrb_int(4)                                      |
-| OP_LOADI_5'      | B            | R(a) = mrb_int(5)                                      |
-| OP_LOADI_6'      | B            | R(a) = mrb_int(6)                                      |
-| OP_LOADI_7'      | B            | R(a) = mrb_int(7)                                      |
-| OP_LOADI16'      | BsS          | R(a) = mrb_int(b)                                      |
-| OP_LOADSYM"      | BB           | R(a) = Syms(b)                                         |
-| OP_LOADNIL'      | B            | R(a) = nil                                             |
-| OP_LOADSELF'     | B            | R(a) = self                                            |
-| OP_LOADT'        | B            | R(a) = true                                            |
-| OP_LOADF'        | B            | R(a) = false                                           |
-| OP_GETGV"        | BB           | R(a) = getglobal(Syms(b))                              |
-| OP_SETGV"        | BB           | setglobal(Syms(b), R(a))                               |
-| OP_GETSV"        | BB           | R(a) = Special[Syms(b)]                                |
-| OP_SETSV"        | BB           | Special[Syms(b)] = R(a)                                |
-| OP_GETIV"        | BB           | R(a) = ivget(Syms(b))                                  |
-| OP_SETIV"        | BB           | ivset(Syms(b),R(a))                                    |
-| OP_GETCV"        | BB           | R(a) = cvget(Syms(b))                                  |
-| OP_SETCV"        | BB           | cvset(Syms(b),R(a))                                    |
-| OP_GETCONST"     | BB           | R(a) = constget(Syms(b))                               |
-| OP_SETCONST"     | BB           | constset(Syms(b),R(a))                                 |
-| OP_GETMCNST"     | BB           | R(a) = R(a)::Syms(b)                                   |
-| OP_SETMCNST"     | BB           | R(a+1)::Syms(b) = R(a)                                 |
-| OP_GETUPVAR"     | BBB          | R(a) = uvget(b,c)                                      |
-| OP_SETUPVAR"     | BBB          | uvset(b,c,R(a))                                        |
+| OP_MOVE          | BB           | R(a) = R(b)                                            |
+| OP_LOADL         | BB           | R(a) = Pool(b)                                         |
+| OP_LOADI         | BB           | R(a) = mrb_int(b)                                      |
+| OP_LOADINEG      | BB           | R(a) = mrb_int(-b)                                     |
+| OP_LOADI__1      | B            | R(a) = mrb_int(-1)                                     |
+| OP_LOADI_0       | B            | R(a) = mrb_int(0)                                      |
+| OP_LOADI_1       | B            | R(a) = mrb_int(1)                                      |
+| OP_LOADI_2       | B            | R(a) = mrb_int(2)                                      |
+| OP_LOADI_3       | B            | R(a) = mrb_int(3)                                      |
+| OP_LOADI_4       | B            | R(a) = mrb_int(4)                                      |
+| OP_LOADI_5       | B            | R(a) = mrb_int(5)                                      |
+| OP_LOADI_6       | B            | R(a) = mrb_int(6)                                      |
+| OP_LOADI_7       | B            | R(a) = mrb_int(7)                                      |
+| OP_LOADI16       | BsS          | R(a) = mrb_int(b)                                      |
+| OP_LOADSYM       | BB           | R(a) = Syms(b)                                         |
+| OP_LOADNIL       | B            | R(a) = nil                                             |
+| OP_LOADSELF      | B            | R(a) = self                                            |
+| OP_LOADT         | B            | R(a) = true                                            |
+| OP_LOADF         | B            | R(a) = false                                           |
+| OP_GETGV         | BB           | R(a) = getglobal(Syms(b))                              |
+| OP_SETGV         | BB           | setglobal(Syms(b), R(a))                               |
+| OP_GETSV         | BB           | R(a) = Special[Syms(b)]                                |
+| OP_SETSV         | BB           | Special[Syms(b)] = R(a)                                |
+| OP_GETIV         | BB           | R(a) = ivget(Syms(b))                                  |
+| OP_SETIV         | BB           | ivset(Syms(b),R(a))                                    |
+| OP_GETCV         | BB           | R(a) = cvget(Syms(b))                                  |
+| OP_SETCV         | BB           | cvset(Syms(b),R(a))                                    |
+| OP_GETCONST      | BB           | R(a) = constget(Syms(b))                               |
+| OP_SETCONST      | BB           | constset(Syms(b),R(a))                                 |
+| OP_GETMCNST      | BB           | R(a) = R(a)::Syms(b)                                   |
+| OP_SETMCNST      | BB           | R(a+1)::Syms(b) = R(a)                                 |
+| OP_GETUPVAR      | BBB          | R(a) = uvget(b,c)                                      |
+| OP_SETUPVAR      | BBB          | uvset(b,c,R(a))                                        |
 | OP_JMP           | S            | pc=a                                                   |
-| OP_JMPIF'        | BS           | if R(a) pc=b                                           |
-| OP_JMPNOT'       | BS           | if !R(a) pc=b                                          |
-| OP_JMPNIL'       | BS           | if R(a)==nil pc=b                                      |
-| OP_ONERR         | S            | rescue_push(a)                                         |
-| OP_EXCEPT'       | B            | R(a) = exc                                             |
-| OP_RESCUE"       | BB           | R(b) = R(a).isa?(R(b))                                 |
-| OP_POPERR'       | B            | a.times{rescue_pop()}                                  |
-| OP_RAISE'        | B            | raise(R(a))                                            |
-| OP_EPUSH'        | B            | ensure_push(SEQ[a])                                    |
-| OP_EPOP'         | B            | A.times{ensure_pop().call}                             |
-| OP_SENDV"        | BB           | R(a) = call(R(a),Syms(b),*R(a+1))                      |
-| OP_SENDVB"       | BB           | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))              |
-| OP_SEND"         | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))            |
-| OP_SENDB"        | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1))  |
+| OP_JMPIF         | BS           | if R(a) pc=b                                           |
+| OP_JMPNOT        | BS           | if !R(a) pc=b                                          |
+| OP_JMPNIL        | BS           | if R(a)==nil pc=b                                      |
+| OP_JMPUW         | S            | unwind_and_jump_to(a)                                  |
+| OP_EXCEPT        | B            | R(a) = exc                                             |
+| OP_RESCUE        | BB           | R(b) = R(a).isa?(R(b))                                 |
+| OP_RAISEIF       | B            | raise(R(a)) if R(a)                                    |
+| OP_SENDV         | BB           | R(a) = call(R(a),Syms(b),*R(a+1))                      |
+| OP_SENDVB        | BB           | R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2))              |
+| OP_SEND          | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c))            |
+| OP_SENDB         | BBB          | R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1))  |
 | OP_CALL          | -            | R(0) = self.call(frame.argc, frame.argv)               |
-| OP_SUPER"        | BB           | R(a) = super(R(a+1),... ,R(a+b+1))                     |
-| OP_ARGARY'       | BS           | R(a) = argument array (16=5:1:5:1:4)                   |
+| OP_SUPER         | BB           | R(a) = super(R(a+1),... ,R(a+b+1))                     |
+| OP_ARGARY        | BS           | R(a) = argument array (16=5:1:5:1:4)                   |
 | OP_ENTER         | W            | arg setup according to flags (23=5:5:1:5:5:1:1)        |
-| OP_KEY_P"        | BB           | R(a) = kdict.key?(Syms(b))                             |
+| OP_KEY_P         | BB           | R(a) = kdict.key?(Syms(b))                             |
 | OP_KEYEND        | -            | raise unless kdict.empty?                              |
-| OP_KARG"         | BB           | R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))           |
-| OP_RETURN'       | B            | return R(a) (normal)                                   |
-| OP_RETURN_BLK'   | B            | return R(a) (in-block return)                          |
-| OP_BREAK'        | B            | break R(a)                                             |
-| OP_BLKPUSH'      | BS           | R(a) = block (16=5:1:5:1:4)                            |
-| OP_ADD'          | B            | R(a) = R(a)+R(a+1)                                     |
-| OP_ADDI"         | BB           | R(a) = R(a)+mrb_int(b)                                 |
-| OP_SUB'          | B            | R(a) = R(a)-R(a+1)                                     |
-| OP_SUBI"         | BB           | R(a) = R(a)-mrb_int(b)                                 |
-| OP_MUL'          | B            | R(a) = R(a)*R(a+1)                                     |
-| OP_DIV'          | B            | R(a) = R(a)/R(a+1)                                     |
-| OP_EQ'           | B            | R(a) = R(a)==R(a+1)                                    |
-| OP_LT'           | B            | R(a) = R(a)<R(a+1)                                     |
-| OP_LE'           | B            | R(a) = R(a)<=R(a+1)                                    |
-| OP_GT'           | B            | R(a) = R(a)>R(a+1)                                     |
-| OP_GE'           | B            | R(a) = R(a)>=R(a+1)                                    |
-| OP_ARRAY"        | BB           | R(a) = ary_new(R(a),R(a+1)..R(a+b))                    |
-| OP_ARRAY2"       | BBB          | R(a) = ary_new(R(b),R(b+1)..R(b+c))                    |
-| OP_ARYCAT'       | B            | ary_cat(R(a),R(a+1))                                   |
-| OP_ARYPUSH'      | B            | ary_push(R(a),R(a+1))                                  |
-| OP_ARYDUP'       | B            | R(a) = ary_dup(R(a))                                   |
-| OP_AREF"         | BBB          | R(a) = R(b)[c]                                         |
-| OP_ASET"         | BBB          | R(a)[c] = R(b)                                         |
-| OP_APOST"        | BBB          | *R(a),R(a+1)..R(a+c) = R(a)[b..]                       |
-| OP_INTERN'       | B            | R(a) = intern(R(a))                                    |
-| OP_STRING"       | BB           | R(a) = str_dup(Lit(b))                                 |
-| OP_STRCAT'       | B            | str_cat(R(a),R(a+1))                                   |
-| OP_HASH"         | BB           | R(a) = hash_new(R(a),R(a+1)..R(a+b))                   |
-| OP_HASHADD"      | BB           | R(a) = hash_push(R(a),R(a+1)..R(a+b))                  |
-| OP_HASHCAT'      | B            | R(a) = hash_cat(R(a),R(a+1))                           |
-| OP_LAMBDA"       | BB           | R(a) = lambda(SEQ[b],OP_L_LAMBDA)                      |
-| OP_BLOCK"        | BB           | R(a) = lambda(SEQ[b],OP_L_BLOCK)                       |
-| OP_METHOD"       | BB           | R(a) = lambda(SEQ[b],OP_L_METHOD)                      |
-| OP_RANGE_INC'    | B            | R(a) = range_new(R(a),R(a+1),FALSE)                    |
-| OP_RANGE_EXC'    | B            | R(a) = range_new(R(a),R(a+1),TRUE)                     |
-| OP_OCLASS'       | B            | R(a) = ::Object                                        |
-| OP_CLASS"        | BB           | R(a) = newclass(R(a),Syms(b),R(a+1))                   |
-| OP_MODULE"       | BB           | R(a) = newmodule(R(a),Syms(b))                         |
-| OP_EXEC"         | BB           | R(a) = blockexec(R(a),SEQ[b])                          |
-| OP_DEF"          | BB           | R(a).newmethod(Syms(b),R(a+1))                         |
-| OP_ALIAS"        | BB           | alias_method(target_class,Syms(a),Syms(b))             |
-| OP_UNDEF'        | B            | undef_method(target_class,Syms(a))                     |
-| OP_SCLASS'       | B            | R(a) = R(a).singleton_class                            |
-| OP_TCLASS'       | B            | R(a) = target_class                                    |
-| OP_DEBUG"        | BBB          | print a,b,c                                            |
-| OP_ERR'          | B            | raise(LocalJumpError, Lit(a))                          |
-| OP_EXT1          | -            | make 1st operand 16bit                                 |
-| OP_EXT2          | -            | make 2nd operand 16bit                                 |
-| OP_EXT3          | -            | make 1st and 2nd operands 16bit                        |
+| OP_KARG          | BB           | R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))           |
+| OP_RETURN        | B            | return R(a) (normal)                                   |
+| OP_RETURN_BLK    | B            | return R(a) (in-block return)                          |
+| OP_BREAK         | B            | break R(a)                                             |
+| OP_BLKPUSH       | BS           | R(a) = block (16=5:1:5:1:4)                            |
+| OP_ADD           | B            | R(a) = R(a)+R(a+1)                                     |
+| OP_ADDI          | BB           | R(a) = R(a)+mrb_int(b)                                 |
+| OP_SUB           | B            | R(a) = R(a)-R(a+1)                                     |
+| OP_SUBI          | BB           | R(a) = R(a)-mrb_int(b)                                 |
+| OP_MUL           | B            | R(a) = R(a)*R(a+1)                                     |
+| OP_DIV           | B            | R(a) = R(a)/R(a+1)                                     |
+| OP_EQ            | B            | R(a) = R(a)==R(a+1)                                    |
+| OP_LT            | B            | R(a) = R(a)<R(a+1)                                     |
+| OP_LE            | B            | R(a) = R(a)<=R(a+1)                                    |
+| OP_GT            | B            | R(a) = R(a)>R(a+1)                                     |
+| OP_GE            | B            | R(a) = R(a)>=R(a+1)                                    |
+| OP_ARRAY         | BB           | R(a) = ary_new(R(a),R(a+1)..R(a+b))                    |
+| OP_ARRAY2        | BBB          | R(a) = ary_new(R(b),R(b+1)..R(b+c))                    |
+| OP_ARYCAT        | B            | ary_cat(R(a),R(a+1))                                   |
+| OP_ARYPUSH       | B            | ary_push(R(a),R(a+1))                                  |
+| OP_ARYDUP        | B            | R(a) = ary_dup(R(a))                                   |
+| OP_AREF          | BBB          | R(a) = R(b)[c]                                         |
+| OP_ASET          | BBB          | R(a)[c] = R(b)                                         |
+| OP_APOST         | BBB          | *R(a),R(a+1)..R(a+c) = R(a)[b..]                       |
+| OP_INTERN        | B            | R(a) = intern(R(a))                                    |
+| OP_STRING        | BB           | R(a) = str_dup(Lit(b))                                 |
+| OP_STRCAT        | B            | str_cat(R(a),R(a+1))                                   |
+| OP_HASH          | BB           | R(a) = hash_new(R(a),R(a+1)..R(a+b))                   |
+| OP_HASHADD       | BB           | R(a) = hash_push(R(a),R(a+1)..R(a+b))                  |
+| OP_HASHCAT       | B            | R(a) = hash_cat(R(a),R(a+1))                           |
+| OP_LAMBDA        | BB           | R(a) = lambda(SEQ[b],OP_L_LAMBDA)                      |
+| OP_BLOCK         | BB           | R(a) = lambda(SEQ[b],OP_L_BLOCK)                       |
+| OP_METHOD        | BB           | R(a) = lambda(SEQ[b],OP_L_METHOD)                      |
+| OP_RANGE_INC     | B            | R(a) = range_new(R(a),R(a+1),FALSE)                    |
+| OP_RANGE_EXC     | B            | R(a) = range_new(R(a),R(a+1),TRUE)                     |
+| OP_OCLASS        | B            | R(a) = ::Object                                        |
+| OP_CLASS         | BB           | R(a) = newclass(R(a),Syms(b),R(a+1))                   |
+| OP_MODULE        | BB           | R(a) = newmodule(R(a),Syms(b))                         |
+| OP_EXEC          | BB           | R(a) = blockexec(R(a),SEQ[b])                          |
+| OP_DEF           | BB           | R(a).newmethod(Syms(b),R(a+1))                         |
+| OP_ALIAS         | BB           | alias_method(target_class,Syms(a),Syms(b))             |
+| OP_UNDEF         | B            | undef_method(target_class,Syms(a))                     |
+| OP_SCLASS        | B            | R(a) = R(a).singleton_class                            |
+| OP_TCLASS        | B            | R(a) = target_class                                    |
+| OP_DEBUG         | BBB          | print a,b,c                                            |
+| OP_ERR           | B            | raise(LocalJumpError, Lit(a))                          |
 | OP_STOP          | -            | stop VM                                                |
 |------------------|--------------|--------------------------------------------------------|
diff --git a/examples/targets/build_config_android_arm64-v8a.rb b/examples/targets/build_config_android_arm64-v8a.rb
deleted file mode 100644
index 70b0f4b97..000000000
--- a/examples/targets/build_config_android_arm64-v8a.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-end
-
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
-  params = {
-    :arch => 'arm64-v8a',
-    :platform => 'android-24',
-    :toolchain => :clang,
-  }
-  toolchain :android, params
-
-  conf.gembox 'default'
-end
diff --git a/examples/targets/build_config_android_armeabi.rb b/examples/targets/build_config_android_armeabi.rb
deleted file mode 100644
index 17330242a..000000000
--- a/examples/targets/build_config_android_armeabi.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-end
-
-# Requires Android NDK r13 or later.
-MRuby::CrossBuild.new('android-armeabi') do |conf|
-  params = {
-    :arch => 'armeabi',
-    :platform => 'android-24',
-    :toolchain => :clang,
-  }
-  toolchain :android, params
-
-  conf.gembox 'default'
-end
diff --git a/include/mrbconf.h b/include/mrbconf.h
index 2b1adb24e..89b3e9022 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -25,33 +25,69 @@
 #endif
 
 /* configuration options: */
-/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
-//#define MRB_USE_FLOAT
+/* add -DMRB_USE_FLOAT32 to use float instead of double for floating point numbers */
+//#define MRB_USE_FLOAT32
 
 /* exclude floating point numbers */
-//#define MRB_WITHOUT_FLOAT
+//#define MRB_NO_FLOAT
 
-/* add -DMRB_METHOD_CACHE to use method cache to improve performance */
-//#define MRB_METHOD_CACHE
+/* obsolete configuration */
+#if defined(MRB_USE_FLOAT)
+# define MRB_USE_FLOAT32
+#endif
+
+/* obsolete configuration */
+#if defined(MRB_WITHOUT_FLOAT)
+# define MRB_NO_FLOAT
+#endif
+
+#if defined(MRB_USE_FLOAT32) && defined(MRB_NO_FLOAT)
+#error Cannot define MRB_USE_FLOAT32 and MRB_NO_FLOAT at the same time
+#endif
+
+/* add -DMRB_NO_METHOD_CACHE to disable method cache to save memory */
+//#define MRB_NO_METHOD_CACHE
 /* size of the method cache (need to be the power of 2) */
-//#define MRB_METHOD_CACHE_SIZE (1<<7)
+//#define MRB_METHOD_CACHE_SIZE (1<<8)
 
-/* add -DMRB_METHOD_T_STRUCT on machines that use higher bits of pointers */
-/* no MRB_METHOD_T_STRUCT requires highest 2 bits of function pointers to be zero */
-#ifndef MRB_METHOD_T_STRUCT
+/* add -DMRB_USE_METHOD_T_STRUCT on machines that use higher bits of function pointers */
+/* no MRB_USE_METHOD_T_STRUCT requires highest 2 bits of function pointers to be zero */
+#ifndef MRB_USE_METHOD_T_STRUCT
   // can't use highest 2 bits of function pointers at least on 32bit
   // Windows and 32bit Linux.
 # ifdef MRB_32BIT
-#   define MRB_METHOD_T_STRUCT
+#   define MRB_USE_METHOD_T_STRUCT
+# endif
+#endif
+
+/* define on big endian machines; used by MRB_NAN_BOXING, etc. */
+#ifndef MRB_ENDIAN_BIG
+# if (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
+     (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#  define MRB_ENDIAN_BIG
 # endif
 #endif
 
+/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT32 and MRB_NO_FLOAT */
+//#define MRB_NAN_BOXING
+
+/* represent mrb_value as a word (natural unit of data for the processor) */
+//#define MRB_WORD_BOXING
+
+/* represent mrb_value as a struct; occupies 2 words */
+//#define MRB_NO_BOXING
+
+/* if no specific boxing type is chosen */
+#if !defined(MRB_NAN_BOXING) && !defined(MRB_WORD_BOXING) && !defined(MRB_NO_BOXING)
+# define MRB_WORD_BOXING
+#endif
+
 /* add -DMRB_INT32 to use 32bit integer for mrb_int; conflict with MRB_INT64;
    Default for 32-bit CPU mode. */
 //#define MRB_INT32
 
 /* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT32;
-   Default for 64-bit CPU mode. */
+   Default for 64-bit CPU mode (unless using MRB_NAN_BOXING). */
 //#define MRB_INT64
 
 /* if no specific integer type is chosen */
@@ -65,19 +101,8 @@
 # endif
 #endif
 
-/* define on big endian machines; used by MRB_NAN_BOXING, etc. */
-#ifndef MRB_ENDIAN_BIG
-# if (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
-     (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#  define MRB_ENDIAN_BIG
-# endif
-#endif
-
-/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */
-//#define MRB_NAN_BOXING
-
-/* represent mrb_value as a word (natural unit of data for the processor) */
-//#define MRB_WORD_BOXING
+/* call malloc_trim(0) from mrb_full_gc() */
+//#define MRB_USE_MALLOC_TRIM
 
 /* string class to handle UTF-8 encoding */
 //#define MRB_UTF8_STRING
@@ -160,6 +185,10 @@
 
 /* A profile for micro controllers */
 #if defined(MRB_CONSTRAINED_BASELINE_PROFILE)
+# ifndef MRB_NO_METHOD_CACHE
+#  define MRB_NO_METHOD_CACHE
+# endif
+
 # ifndef KHASH_DEFAULT_SIZE
 #  define KHASH_DEFAULT_SIZE 16
 # endif
@@ -177,10 +206,6 @@
 
 /* A profile for desktop computers or workstations; rich memory! */
 #elif defined(MRB_MAIN_PROFILE)
-# ifndef MRB_METHOD_CACHE
-#  define MRB_METHOD_CACHE
-# endif
-
 # ifndef MRB_METHOD_CACHE_SIZE
 #  define MRB_METHOD_CACHE_SIZE (1<<10)
 # endif
@@ -195,10 +220,6 @@
 
 /* A profile for server; mruby vm is long life */
 #elif defined(MRB_HIGH_PROFILE)
-# ifndef MRB_METHOD_CACHE
-#  define MRB_METHOD_CACHE
-# endif
-
 # ifndef MRB_METHOD_CACHE_SIZE
 #  define MRB_METHOD_CACHE_SIZE (1<<12)
 # endif
diff --git a/include/mruby.h b/include/mruby.h
index 6d884b146..52bcd58bf 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -89,9 +89,10 @@
 #include <mruby/common.h>
 #include <mruby/value.h>
 #include <mruby/gc.h>
+#include <mruby/presym.h>
 #include <mruby/version.h>
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #include <float.h>
 #ifndef FLT_EPSILON
 #define FLT_EPSILON (1.19209290e-07f)
@@ -103,7 +104,7 @@
 #define LDBL_EPSILON (1.08420217248550443401e-19L)
 #endif
 
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
 #define MRB_FLOAT_EPSILON FLT_EPSILON
 #else
 #define MRB_FLOAT_EPSILON DBL_EPSILON
@@ -146,15 +147,13 @@ typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
 
 typedef struct {
   mrb_sym mid;
-  struct RProc *proc;
+  const struct RProc *proc;
   mrb_value *stackent;
-  uint16_t ridx;
-  uint16_t epos;
   struct REnv *env;
   const mrb_code *pc;           /* return address */
   const mrb_code *err;          /* error position */
-  int argc;
-  int acc;
+  mrb_int argc;
+  mrb_int acc;
   struct RClass *target_class;
 } mrb_callinfo;
 
@@ -176,22 +175,17 @@ struct mrb_context {
   mrb_callinfo *ci;
   mrb_callinfo *cibase, *ciend;
 
-  uint16_t *rescue;                       /* exception handler stack */
-  uint16_t rsize;
-  struct RProc **ensure;                  /* ensure handler stack */
-  uint16_t esize, eidx;
-
   enum mrb_fiber_state status : 4;
   mrb_bool vmexec : 1;
   struct RFiber *fib;
 };
 
 #ifdef MRB_METHOD_CACHE_SIZE
-# define MRB_METHOD_CACHE
+# undef MRB_NO_METHOD_CACHE
 #else
-/* default method cache size: 128 */
+/* default method cache size: 256 */
 /* cache size needs to be power of 2 */
-# define MRB_METHOD_CACHE_SIZE (1<<7)
+# define MRB_METHOD_CACHE_SIZE (1<<8)
 #endif
 
 /**
@@ -205,7 +199,7 @@ struct mrb_context {
  */
 typedef mrb_value (*mrb_func_t)(struct mrb_state *mrb, mrb_value self);
 
-#ifndef MRB_METHOD_T_STRUCT
+#ifndef MRB_USE_METHOD_T_STRUCT
 typedef uintptr_t mrb_method_t;
 #else
 typedef struct {
@@ -217,7 +211,7 @@ typedef struct {
 } mrb_method_t;
 #endif
 
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
 struct mrb_cache_entry {
   struct RClass *c, *c0;
   mrb_sym mid;
@@ -251,10 +245,10 @@ typedef struct mrb_state {
   struct RClass *hash_class;
   struct RClass *range_class;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   struct RClass *float_class;
 #endif
-  struct RClass *fixnum_class;
+  struct RClass *integer_class;
   struct RClass *true_class;
   struct RClass *false_class;
   struct RClass *nil_class;
@@ -263,7 +257,7 @@ typedef struct mrb_state {
 
   mrb_gc gc;
 
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
   struct mrb_cache_entry cache[MRB_METHOD_CACHE_SIZE];
 #endif
 
@@ -276,8 +270,8 @@ typedef struct mrb_state {
 #endif
 
 #ifdef MRB_ENABLE_DEBUG_HOOK
-  void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
-  void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
+  void (*code_fetch_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
+  void (*debug_op_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs);
 #endif
 
 #ifdef MRB_BYTECODE_DECODE_OPTION
@@ -300,7 +294,6 @@ typedef struct mrb_state {
   mrb_atexit_func *atexit_stack;
 #endif
   uint16_t atexit_stack_len;
-  uint16_t ecall_nest;                    /* prevent infinite recursive ecall() */
 } mrb_state;
 
 /**
@@ -325,6 +318,7 @@ typedef struct mrb_state {
  * @see mrb_define_class_under
  */
 MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super);
+MRB_API struct RClass *mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super);
 
 /**
  * Defines a new module.
@@ -334,6 +328,7 @@ MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct
  * @return [struct RClass *] Reference to the newly defined module.
  */
 MRB_API struct RClass *mrb_define_module(mrb_state *mrb, const char *name);
+MRB_API struct RClass *mrb_define_module_id(mrb_state *mrb, mrb_sym name);
 
 MRB_API mrb_value mrb_singleton_class(mrb_state *mrb, mrb_value val);
 MRB_API struct RClass *mrb_singleton_class_ptr(mrb_state *mrb, mrb_value val);
@@ -389,6 +384,7 @@ MRB_API void mrb_prepend_module(mrb_state *mrb, struct RClass *cla, struct RClas
  * @param aspec The method parameters declaration.
  */
 MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t func, mrb_aspec aspec);
+MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
 
 /**
  * Defines a class method.
@@ -416,6 +412,7 @@ MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *n
  * @param aspec The method parameters declaration.
  */
 MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_class_method_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
 
 /**
  * Defines a singleton method
@@ -423,6 +420,7 @@ MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const c
  * @see mrb_define_class_method
  */
 MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
 
 /**
  *  Defines a module function.
@@ -450,6 +448,7 @@ MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, co
  *  @param aspec The method parameters declaration.
  */
 MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec);
+MRB_API void mrb_define_module_function_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec);
 
 /**
  *  Defines a constant.
@@ -478,6 +477,7 @@ MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, cons
  *  @param val The value for the constant.
  */
 MRB_API void mrb_define_const(mrb_state* mrb, struct RClass* cla, const char *name, mrb_value val);
+MRB_API void mrb_define_const_id(mrb_state* mrb, struct RClass* cla, mrb_sym name, mrb_value val);
 
 /**
  * Undefines a method.
@@ -568,6 +568,7 @@ MRB_API void mrb_undef_method_id(mrb_state*, struct RClass*, mrb_sym);
  * @param name The name of the class method to be undefined.
  */
 MRB_API void mrb_undef_class_method(mrb_state *mrb, struct RClass *cls, const char *name);
+MRB_API void mrb_undef_class_method_id(mrb_state *mrb, struct RClass *cls, mrb_sym name);
 
 /**
  * Initialize a new object instance of c class.
@@ -669,6 +670,7 @@ MRB_API struct RClass * mrb_module_new(mrb_state *mrb);
  * @return [mrb_bool] A boolean value.
  */
 MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
+MRB_API mrb_bool mrb_class_defined_id(mrb_state *mrb, mrb_sym name);
 
 /**
  * Gets a class.
@@ -676,7 +678,8 @@ MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
  * @param name The name of the class.
  * @return [struct RClass *] A reference to the class.
 */
-MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_class_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_class_get_id(mrb_state *mrb, mrb_sym name);
 
 /**
  * Gets a exception class.
@@ -684,7 +687,8 @@ MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
  * @param name The name of the class.
  * @return [struct RClass *] A reference to the class.
 */
-MRB_API struct RClass * mrb_exc_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass* mrb_exc_get_id(mrb_state *mrb, mrb_sym name);
+#define mrb_exc_get(mrb, name) mrb_exc_get_id(mrb, mrb_intern_cstr(mrb, name))
 
 /**
  * Returns an mrb_bool. True if inner class was defined, and false if the inner class was not defined.
@@ -716,6 +720,7 @@ MRB_API struct RClass * mrb_exc_get(mrb_state *mrb, const char *name);
  * @return [mrb_bool] A boolean value.
  */
 MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API mrb_bool mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
 
 /**
  * Gets a child class.
@@ -725,6 +730,7 @@ MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, c
  * @return [struct RClass *] A reference to the class.
 */
 MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass * mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
 
 /**
  * Gets a module.
@@ -733,6 +739,7 @@ MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer
  * @return [struct RClass *] A reference to the module.
 */
 MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
+MRB_API struct RClass * mrb_module_get_id(mrb_state *mrb, mrb_sym name);
 
 /**
  * Gets a module defined under another module.
@@ -742,6 +749,8 @@ MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
  * @return [struct RClass *] A reference to the module.
 */
 MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass * mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
+
 /* a function to raise NotImplementedError with current method name */
 MRB_API void mrb_notimplement(mrb_state*);
 /* a function to be replacement of unimplemented method */
@@ -810,9 +819,11 @@ MRB_API mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mi
  * @return [struct RClass *] Reference to the newly defined class
  * @see mrb_define_class
  */
-MRB_API struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
+MRB_API struct RClass* mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
+MRB_API struct RClass* mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super);
 
-MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass* mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
+MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name);
 
 /**
  * Function requires n arguments.
@@ -879,8 +890,8 @@ MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *o
  * | `s`  | {String}       | const char *, {mrb_int} | Receive two arguments; `s!` gives (`NULL`,`0`) for `nil` |
  * | `z`  | {String}       | const char *      | `NULL` terminated string; `z!` gives `NULL` for `nil` |
  * | `a`  | {Array}        | {mrb_value} *, {mrb_int} | Receive two arguments; `a!` gives (`NULL`,`0`) for `nil` |
- * | `f`  | {Fixnum}/{Float} | {mrb_float}       |                                                    |
- * | `i`  | {Fixnum}/{Float} | {mrb_int}         |                                                    |
+ * | `f`  | {Integer}/{Float} | {mrb_float}    |                                                    |
+ * | `i`  | {Integer}/{Float} | {mrb_int}      |                                                    |
  * | `b`  | boolean        | {mrb_bool}        |                                                    |
  * | `n`  | {String}/{Symbol} | {mrb_sym}         |                                                    |
  * | `d`  | data           | void *, {mrb_data_type} const | 2nd argument will be used to check data type so it won't be modified; when `!` follows, the value may be `nil` |
@@ -918,7 +929,7 @@ typedef const char *mrb_args_format;
  *      const char *kw_names[kw_num] = { "a", "b" };
  *      uint32_t kw_required = 0;
  *      mrb_value kw_values[kw_num];
- *      const mrb_kwargs kwargs = { kw_num, kw_values, kw_names, kw_required, NULL };
+ *      const mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, NULL };
  *
  *      mrb_get_args(mrb, ":", &kwargs);
  *      if (mrb_undef_p(kw_values[0])) { kw_values[0] = mrb_fixnum_value(1); }
@@ -929,10 +940,10 @@ typedef const char *mrb_args_format;
  *
  *      mrb_value str, kw_rest;
  *      uint32_t kw_num = 3;
- *      const char *kw_names[kw_num] = { "x", "y", "z" };
+ *      const mrb_sym kw_names[kw_num] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) };
  *      uint32_t kw_required = 1;
  *      mrb_value kw_values[kw_num];
- *      const mrb_kwargs kwargs = { kw_num, kw_values, kw_names, kw_required, &kw_rest };
+ *      const mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, &kw_rest };
  *
  *      mrb_get_args(mrb, "S:", &str, &kwargs);
  *      // or: mrb_get_args(mrb, ":S", &kwargs, &str);
@@ -943,11 +954,11 @@ typedef struct mrb_kwargs mrb_kwargs;
 
 struct mrb_kwargs
 {
-  uint32_t num;
-  mrb_value *values;
-  const char *const *table;
-  uint32_t required;
-  mrb_value *rest;
+  uint32_t num;                 /* number of keyword arguments */
+  uint32_t required;            /* number of required keyword arguments */
+  const mrb_sym *table;         /* C array of symbols for keyword names */
+  mrb_value *values;            /* keyword argument values */
+  mrb_value *rest;              /* keyword rest (dict) */
 };
 
 /**
@@ -1017,6 +1028,7 @@ MRB_API mrb_value mrb_get_arg1(mrb_state *mrb);
  *        FILE *fp = fopen("test.rb","r");
  *        mrb_value obj = mrb_load_file(mrb,fp);
  *        mrb_funcall(mrb, obj, "method_name", 1, mrb_fixnum_value(i));
+ *        mrb_funcall_id(mrb, obj, MRB_SYM(method_name), 1, mrb_fixnum_value(i));
  *        fclose(fp);
  *        mrb_close(mrb);
  *      }
@@ -1029,6 +1041,7 @@ MRB_API mrb_value mrb_get_arg1(mrb_state *mrb);
  * @return [mrb_value] mruby function value.
  */
 MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc, ...);
+MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb_int argc, ...);
 /**
  * Call existing ruby functions. This is basically the type safe version of mrb_funcall.
  *
@@ -1038,15 +1051,14 @@ MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, m
  *      int
  *      main()
  *      {
- *        mrb_int i = 99;
  *        mrb_state *mrb = mrb_open();
+ *        mrb_value obj = mrb_fixnum_value(1);
  *
  *        if (!mrb) { }
- *        mrb_sym m_sym = mrb_intern_lit(mrb, "method_name"); // Symbol for method.
  *
  *        FILE *fp = fopen("test.rb","r");
  *        mrb_value obj = mrb_load_file(mrb,fp);
- *        mrb_funcall_argv(mrb, obj, m_sym, 1, &obj); // Calling ruby function from test.rb.
+ *        mrb_funcall_argv(mrb, obj, MRB_SYM(method_name), 1, &obj); // Calling ruby function from test.rb.
  *        fclose(fp);
  *        mrb_close(mrb);
  *       }
@@ -1064,7 +1076,7 @@ MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name,
  */
 MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv, mrb_value block);
 /**
- * Create a symbol
+ * Create a symbol from C string. But usually it's better to use MRB_SYM(sym) and MRB_QSYM(qsym).
  *
  * Example:
  *
@@ -1072,7 +1084,9 @@ MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym
  *     :pizza # => :pizza
  *
  *     // C style:
- *     mrb_sym m_sym = mrb_intern_lit(mrb, "pizza"); //  => :pizza
+ *     mrb_sym sym1 = mrb_intern_lit(mrb, "pizza"); //  => :pizza
+ *     mrb_sym sym2 = MRB_SYM(pizza);               //  => :pizza
+ *     mrb_sym sym3 = MRB_SYM(pizza_p);             //  => :pizza?
  *
  * @param mrb The current mruby state.
  * @param str The string to be symbolized
@@ -1081,8 +1095,14 @@ MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym
 MRB_API mrb_sym mrb_intern_cstr(mrb_state *mrb, const char* str);
 MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t);
 MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
-#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, mrb_strlen_lit(lit))
+#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit))
 MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value);
+/* mrb_intern_check series functions returns 0 if the symbol is not defined */
+MRB_API mrb_sym mrb_intern_check_cstr(mrb_state*,const char*);
+MRB_API mrb_sym mrb_intern_check(mrb_state*,const char*,size_t);
+MRB_API mrb_sym mrb_intern_check_str(mrb_state*,mrb_value);
+/* mrb_check_intern series functions returns nil if the symbol is not defined */
+/* otherwise returns mrb_value */
 MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
 MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
 MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
@@ -1180,9 +1200,9 @@ MRB_API void mrb_close(mrb_state *mrb);
 MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*);
 
 MRB_API mrb_value mrb_top_self(mrb_state *mrb);
-MRB_API mrb_value mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep);
-MRB_API mrb_value mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep);
-MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *iseq);
+MRB_API mrb_value mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep);
+MRB_API mrb_value mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep);
+MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *iseq);
 /* compatibility macros */
 #define mrb_toplevel_run_keep(m,p,k) mrb_top_run((m),(p),mrb_top_self(m),(k))
 #define mrb_toplevel_run(m,p) mrb_toplevel_run_keep((m),(p),0)
@@ -1197,7 +1217,7 @@ MRB_API mrb_bool mrb_obj_equal(mrb_state *mrb, mrb_value a, mrb_value b);
 MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
 MRB_API mrb_value mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base);
 MRB_API mrb_value mrb_Integer(mrb_state *mrb, mrb_value val);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val);
 #endif
 MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
@@ -1230,12 +1250,15 @@ MRB_API void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*
 } while (0)
 MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*);
 
-MRB_API mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
+MRB_API mrb_value mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method);
+#define mrb_convert_type(mrb, val, type, tname, method) mrb_type_convert(mrb, val, type, mrb_intern_lit(mrb, method))
+MRB_API mrb_value mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method);
+#define mrb_check_convert_type(mrb, val, type, tname, method) mrb_type_convert_check(mrb, val, type, mrb_intern_lit(mrb, method))
+
 MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj);
 MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
 MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
 MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
-MRB_API mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
 MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
 MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
 MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
@@ -1276,25 +1299,26 @@ MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap);
    + those E_* macros requires mrb_state* variable named mrb.
    + exception objects obtained from those macros are local to mrb
 */
-#define E_RUNTIME_ERROR             (mrb_exc_get(mrb, "RuntimeError"))
-#define E_TYPE_ERROR                (mrb_exc_get(mrb, "TypeError"))
-#define E_ARGUMENT_ERROR            (mrb_exc_get(mrb, "ArgumentError"))
-#define E_INDEX_ERROR               (mrb_exc_get(mrb, "IndexError"))
-#define E_RANGE_ERROR               (mrb_exc_get(mrb, "RangeError"))
-#define E_NAME_ERROR                (mrb_exc_get(mrb, "NameError"))
-#define E_NOMETHOD_ERROR            (mrb_exc_get(mrb, "NoMethodError"))
-#define E_SCRIPT_ERROR              (mrb_exc_get(mrb, "ScriptError"))
-#define E_SYNTAX_ERROR              (mrb_exc_get(mrb, "SyntaxError"))
-#define E_LOCALJUMP_ERROR           (mrb_exc_get(mrb, "LocalJumpError"))
-#define E_REGEXP_ERROR              (mrb_exc_get(mrb, "RegexpError"))
-#define E_FROZEN_ERROR              (mrb_exc_get(mrb, "FrozenError"))
-
-#define E_NOTIMP_ERROR              (mrb_exc_get(mrb, "NotImplementedError"))
-#ifndef MRB_WITHOUT_FLOAT
-#define E_FLOATDOMAIN_ERROR         (mrb_exc_get(mrb, "FloatDomainError"))
+#define E_RUNTIME_ERROR             (mrb_exc_get_id(mrb, MRB_SYM(RuntimeError)))
+#define E_TYPE_ERROR                (mrb_exc_get_id(mrb, MRB_SYM(TypeError)))
+#define E_ZERODIV_ERROR             (mrb_exc_get_id(mrb, MRB_SYM(ZeroDivisionError)))
+#define E_ARGUMENT_ERROR            (mrb_exc_get_id(mrb, MRB_SYM(ArgumentError)))
+#define E_INDEX_ERROR               (mrb_exc_get_id(mrb, MRB_SYM(IndexError)))
+#define E_RANGE_ERROR               (mrb_exc_get_id(mrb, MRB_SYM(RangeError)))
+#define E_NAME_ERROR                (mrb_exc_get_id(mrb, MRB_SYM(NameError)))
+#define E_NOMETHOD_ERROR            (mrb_exc_get_id(mrb, MRB_SYM(NoMethodError)))
+#define E_SCRIPT_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(ScriptError)))
+#define E_SYNTAX_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(SyntaxError)))
+#define E_LOCALJUMP_ERROR           (mrb_exc_get_id(mrb, MRB_SYM(LocalJumpError)))
+#define E_REGEXP_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(RegexpError)))
+#define E_FROZEN_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(FrozenError)))
+
+#define E_NOTIMP_ERROR              (mrb_exc_get_id(mrb, MRB_SYM(NotImplementedError)))
+#ifndef MRB_NO_FLOAT
+#define E_FLOATDOMAIN_ERROR         (mrb_exc_get_id(mrb, MRB_SYM(FloatDomainError)))
 #endif
 
-#define E_KEY_ERROR                 (mrb_exc_get(mrb, "KeyError"))
+#define E_KEY_ERROR                 (mrb_exc_get_id(mrb, MRB_SYM(KeyError)))
 
 MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
 MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
@@ -1313,7 +1337,7 @@ MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj);
 MRB_API void mrb_gc_unregister(mrb_state *mrb, mrb_value obj);
 
 MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
-#define mrb_int(mrb, val) mrb_fixnum(mrb_to_int(mrb, val))
+#define mrb_int(mrb, val) mrb_integer(mrb_to_int(mrb, val))
 /* string type checking (contrary to the name, it doesn't convert) */
 MRB_API mrb_value mrb_to_str(mrb_state *mrb, mrb_value val);
 MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
@@ -1324,6 +1348,7 @@ MRB_INLINE void mrb_check_frozen(mrb_state *mrb, void *o)
 }
 
 MRB_API void mrb_define_alias(mrb_state *mrb, struct RClass *c, const char *a, const char *b);
+MRB_API void mrb_define_alias_id(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b);
 MRB_API const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
 MRB_API void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
 
@@ -1360,7 +1385,7 @@ MRB_API mrb_value mrb_fiber_alive_p(mrb_state *mrb, mrb_value fib);
  *
  * Implemented in mruby-fiber
  */
-#define E_FIBER_ERROR (mrb_exc_get(mrb, "FiberError"))
+#define E_FIBER_ERROR (mrb_exc_get_id(mrb, MRB_SYM(FiberError)))
 MRB_API void mrb_stack_extend(mrb_state*, mrb_int);
 
 /* memory pool implementation */
diff --git a/include/mruby/array.h b/include/mruby/array.h
index 92c86a8c5..5164efa69 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -21,7 +21,14 @@ typedef struct mrb_shared_array {
   mrb_value *ptr;
 } mrb_shared_array;
 
-#define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
+#if defined(MRB_32BIT) && defined(MRB_NO_BOXING)
+# define MRB_ARY_NO_EMBED
+# define MRB_ARY_EMBED_LEN_MAX 0
+#else
+# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
+mrb_static_assert(MRB_ARY_EMBED_LEN_MAX > 0, "MRB_ARY_EMBED_LEN_MAX > 0");
+#endif
+
 struct RArray {
   MRB_OBJECT_HEADER;
   union {
@@ -33,7 +40,9 @@ struct RArray {
       } aux;
       mrb_value *ptr;
     } heap;
-    void *ary[3];
+#ifndef MRB_ARY_NO_EMBED
+    mrb_value ary[MRB_ARY_EMBED_LEN_MAX];
+#endif
   } as;
 };
 
@@ -41,13 +50,21 @@ struct RArray {
 #define mrb_ary_value(p)  mrb_obj_value((void*)(p))
 #define RARRAY(v)  ((struct RArray*)(mrb_ptr(v)))
 
+#ifdef MRB_ARY_NO_EMBED
+#define ARY_EMBED_P(a) 0
+#define ARY_UNSET_EMBED_FLAG(a) (void)0
+#define ARY_EMBED_LEN(a) 0
+#define ARY_SET_EMBED_LEN(a,len) (void)0
+#define ARY_EMBED_PTR(a) 0
+#else
 #define MRB_ARY_EMBED_MASK  7
 #define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
 #define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
 #define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
 #define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
-#define ARY_EMBED_PTR(a) ((mrb_value*)(&(a)->as.ary))
-
+#define ARY_EMBED_PTR(a) ((a)->as.ary)
+#endif
+  
 #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(a)->as.heap.len)
 #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
 #define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
diff --git a/include/mruby/boxing_nan.h b/include/mruby/boxing_nan.h
index fae3b7630..3a99aeca6 100644
--- a/include/mruby/boxing_nan.h
+++ b/include/mruby/boxing_nan.h
@@ -7,12 +7,12 @@
 #ifndef MRUBY_BOXING_NAN_H
 #define MRUBY_BOXING_NAN_H
 
-#ifdef MRB_USE_FLOAT
-# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<----
+#ifdef MRB_USE_FLOAT32
+# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT32 conflict <<----
 #endif
 
-#ifdef MRB_WITHOUT_FLOAT
-# error ---->> MRB_NAN_BOXING and MRB_WITHOUT_FLOAT conflict <<----
+#ifdef MRB_NO_FLOAT
+# error ---->> MRB_NAN_BOXING and MRB_NO_FLOAT conflict <<----
 #endif
 
 #ifdef MRB_INT64
@@ -30,76 +30,91 @@
  * In order to get enough bit size to save TT, all pointers are shifted 2 bits
  * in the right direction. Also, TTTTTT is the mrb_vtype + 1;
  */
-typedef struct mrb_value {
-  union {
-    mrb_float f;
-    union {
-      void *p;
-      struct {
-        MRB_ENDIAN_LOHI(
-          uint32_t ttt;
-          ,union {
-            mrb_int i;
-            mrb_sym sym;
-          };
-        )
-      };
+typedef uint64_t mrb_value;
+
+union mrb_value_ {
+  mrb_float f;
+  uint64_t u;
 #ifdef MRB_64BIT
-      struct RCptr *vp;
+  void *p;
 #endif
-    } value;
+  struct {
+    MRB_ENDIAN_LOHI(
+      uint32_t ttt;
+      ,uint32_t i;
+    )
   };
-} mrb_value;
+};
 
-#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
+{
+  union mrb_value_ x;
+  x.u = v;
+  return x;
+}
 
-#define mrb_tt(o)       ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14)-1)
-#define mrb_type(o)     (enum mrb_vtype)((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT)
-#define mrb_ptr(o)      ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2))
-#define mrb_float(o)    (o).f
-#define mrb_fixnum(o)   (o).value.i
-#define mrb_symbol(o)   (o).value.sym
+#define mrb_tt(o)       ((enum mrb_vtype)((mrb_val_union(o).ttt & 0xfc000)>>14)-1)
+#define mrb_type(o)     (enum mrb_vtype)((uint32_t)0xfff00000 < mrb_val_union(o).ttt ? mrb_tt(o) : MRB_TT_FLOAT)
+#define mrb_float(o)    mrb_val_union(o).f
+#define mrb_fixnum(o)   ((mrb_int)mrb_val_union(o).i)
+#define mrb_integer(o)  mrb_fixnum(o)
+#define mrb_symbol(o)   ((mrb_sym)mrb_val_union(o).i)
 
 #ifdef MRB_64BIT
-MRB_API mrb_value mrb_nan_boxing_cptr_value(struct mrb_state*, void*);
+#define mrb_ptr(o)      ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)(mrb_val_union(o).p)))<<2))
 #define mrb_cptr(o)     (((struct RCptr*)mrb_ptr(o))->p)
 #define BOXNAN_SHIFT_LONG_POINTER(v) (((uintptr_t)(v)>>34)&0x3fff)
 #else
-#define mrb_cptr(o)     ((o).value.p)
+#define mrb_ptr(o)      ((void*)mrb_val_union(o).i)
+#define mrb_cptr(o)     mrb_ptr(o)
 #define BOXNAN_SHIFT_LONG_POINTER(v) 0
 #endif
 
-#define BOXNAN_SET_VALUE(o, tt, attr, v) do {\
-  (o).attr = (v);\
-  (o).value.ttt = 0xfff00000 | (((tt)+1)<<14);\
+#define BOXNAN_SET_VALUE(o, tt, attr, v) do { \
+  union mrb_value_ mrb_value_union_variable; \
+  mrb_value_union_variable.attr = (v);\
+  mrb_value_union_variable.ttt = 0xfff00000 | (((tt)+1)<<14);\
+  o = mrb_value_union_variable.u;\
 } while (0)
 
+#ifdef MRB_64BIT
 #define BOXNAN_SET_OBJ_VALUE(o, tt, v) do {\
-  (o).value.p = (void*)((uintptr_t)(v)>>2);\
-  (o).value.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
+  union mrb_value_ mrb_value_union_variable;\
+  mrb_value_union_variable.p = (void*)((uintptr_t)(v)>>2);\
+  mrb_value_union_variable.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
+  o = mrb_value_union_variable.u;\
 } while (0)
+#else
+#define BOXNAN_SET_OBJ_VALUE(o, tt, v) BOXNAN_SET_VALUE(o, tt, i, (uint32_t)v)
+#endif
 
 #define SET_FLOAT_VALUE(mrb,r,v) do { \
-  if ((v) != (v)) { \
-    (r).value.ttt = 0x7ff80000; \
-    (r).value.i = 0; \
+  union mrb_value_ mrb_value_union_variable; \
+  if ((v) != (v)) { /* NaN */ \
+    mrb_value_union_variable.ttt = 0x7ff80000; \
+    mrb_value_union_variable.i = 0; \
   } \
   else { \
-    (r).f = v; \
-  }} while(0)
+    mrb_value_union_variable.f = (v); \
+  } \
+  r = mrb_value_union_variable.u; \
+} while(0)
 
-#define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
-#define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
-#define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
-#define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
+#define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 0)
+#define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, i, 1)
+#define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, i, 1)
+#define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, i, 1)
+#define SET_INT_VALUE(mrb, r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
+#define SET_FIXNUM_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_INTEGER, i, (uint32_t)(n))
+#define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, i, (uint32_t)(v))
 #define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v))
 #ifdef MRB_64BIT
+MRB_API mrb_value mrb_nan_boxing_cptr_value(struct mrb_state*, void*);
 #define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_nan_boxing_cptr_value(mrb, v))
 #else
-#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_VALUE(r, MRB_TT_CPTR, value.p, v)
+#define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_VALUE(r, MRB_TT_CPTR, p, v)
 #endif
-#define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
+#define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, i, 0)
 
 #endif  /* MRUBY_BOXING_NAN_H */
diff --git a/include/mruby/boxing_no.h b/include/mruby/boxing_no.h
index 7573428e6..0b14590d9 100644
--- a/include/mruby/boxing_no.h
+++ b/include/mruby/boxing_no.h
@@ -11,7 +11,7 @@
 #define MRB_SYMBOL_SHIFT 0
 
 union mrb_value_union {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_float f;
 #endif
   void *p;
@@ -24,16 +24,13 @@ typedef struct mrb_value {
   enum mrb_vtype tt;
 } mrb_value;
 
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
-#endif
-
 #define mrb_ptr(o)      (o).value.p
 #define mrb_cptr(o)     mrb_ptr(o)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #define mrb_float(o)    (o).value.f
 #endif
 #define mrb_fixnum(o)   (o).value.i
+#define mrb_integer(o)  mrb_fixnum(o)
 #define mrb_symbol(o)   (o).value.sym
 #define mrb_type(o)     (o).tt
 
@@ -46,8 +43,9 @@ typedef struct mrb_value {
 #define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
 #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
 #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
-#define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
-#ifndef MRB_WITHOUT_FLOAT
+#define SET_INT_VALUE(mrb,r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#define SET_FIXNUM_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#ifndef MRB_NO_FLOAT
 #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
 #endif
 #define SET_SYM_VALUE(r,v) BOXNIX_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
diff --git a/include/mruby/boxing_word.h b/include/mruby/boxing_word.h
index 1b7815b7f..d7b5ff990 100644
--- a/include/mruby/boxing_word.h
+++ b/include/mruby/boxing_word.h
@@ -11,13 +11,18 @@
 #error MRB_INT64 cannot be used with MRB_WORD_BOXING in 32-bit mode.
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 struct RFloat {
   MRB_OBJECT_HEADER;
   mrb_float f;
 };
 #endif
 
+struct RInteger {
+  MRB_OBJECT_HEADER;
+  mrb_int i;
+};
+
 enum mrb_special_consts {
   MRB_Qnil    =  0,
   MRB_Qfalse  =  4,
@@ -47,13 +52,13 @@ enum mrb_special_consts {
 #define BOXWORD_IMMEDIATE_MASK  0x07
 
 #define BOXWORD_SHIFT_VALUE(o,n,t) \
-  (t)(((long)(o).w) >> BOXWORD_##n##_SHIFT)
+  (t)(((intptr_t)(o)) >> BOXWORD_##n##_SHIFT)
 #define BOXWORD_SET_SHIFT_VALUE(o,n,v) \
-  ((o).w = (((unsigned long)(v)) << BOXWORD_##n##_SHIFT) | BOXWORD_##n##_FLAG)
+  ((o) = (((uintptr_t)(v)) << BOXWORD_##n##_SHIFT) | BOXWORD_##n##_FLAG)
 #define BOXWORD_SHIFT_VALUE_P(o,n) \
-  (((o).w & BOXWORD_##n##_MASK) == BOXWORD_##n##_FLAG)
+  (((o) & BOXWORD_##n##_MASK) == BOXWORD_##n##_FLAG)
 #define BOXWORD_OBJ_TYPE_P(o,n) \
-  (!mrb_immediate_p(o) && (o).value.bp->tt == MRB_TT_##n)
+  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
 
 /*
  * mrb_value representation:
@@ -66,62 +71,74 @@ enum mrb_special_consts {
  *   symbol: ...SSSS SS10 (use only upper 32-bit as symbol value on 64-bit CPU)
  *   object: ...PPPP P000 (any bits are 1)
  */
-typedef union mrb_value {
-  union {
-    void *p;
+typedef uintptr_t mrb_value;
+union mrb_value_ {
+  void *p;
 #ifdef MRB_64BIT
-    /* use struct to avoid bit shift. */
-    struct {
-      MRB_ENDIAN_LOHI(
-        mrb_sym sym;
-        ,uint32_t sym_flag;
-      )
-    };
+  /* use struct to avoid bit shift. */
+  struct {
+    MRB_ENDIAN_LOHI(
+      mrb_sym sym;
+      ,uint32_t sym_flag;
+    )
+  };
 #endif
-    struct RBasic *bp;
-#ifndef MRB_WITHOUT_FLOAT
-    struct RFloat *fp;
+  struct RBasic *bp;
+#ifndef MRB_NO_FLOAT
+  struct RFloat *fp;
 #endif
-    struct RCptr *vp;
-  } value;
-  unsigned long w;
-} mrb_value;
+  struct RInteger *ip;
+  struct RCptr *vp;
+  uintptr_t w;
+};
+
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
+{
+  union mrb_value_ x;
+  x.w = v;
+  return x;
+}
 
 MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
-MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
 #endif
+MRB_API mrb_value mrb_word_boxing_int_value(struct mrb_state*, mrb_int);
 
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float_pool(mrb,f) mrb_word_boxing_float_pool(mrb,f)
-#endif
+#define mrb_immediate_p(o) ((o) & BOXWORD_IMMEDIATE_MASK || (o) == MRB_Qnil)
 
-#define mrb_ptr(o)     (o).value.p
-#define mrb_cptr(o)    (o).value.vp->p
-#ifndef MRB_WITHOUT_FLOAT
-#define mrb_float(o)   (o).value.fp->f
+#define mrb_ptr(o)     mrb_val_union(o).p
+#define mrb_cptr(o)    mrb_val_union(o).vp->p
+#ifndef MRB_NO_FLOAT
+#define mrb_float(o)   mrb_val_union(o).fp->f
 #endif
 #define mrb_fixnum(o)  BOXWORD_SHIFT_VALUE(o, FIXNUM, mrb_int)
+MRB_INLINE mrb_int
+mrb_integer_func(mrb_value o) {
+  if (mrb_immediate_p(o)) return mrb_fixnum(o);
+  return mrb_val_union(o).ip->i;
+}
+#define mrb_integer(o) mrb_integer_func(o)
 #ifdef MRB_64BIT
-#define mrb_symbol(o)  (o).value.sym
+#define mrb_symbol(o)  mrb_val_union(o).sym
 #else
 #define mrb_symbol(o)  BOXWORD_SHIFT_VALUE(o, SYMBOL, mrb_sym)
 #endif
-#define mrb_bool(o)    (((o).w & ~(unsigned long)MRB_Qfalse) != 0)
+#define mrb_bool(o)    (((o) & ~(unsigned long)MRB_Qfalse) != 0)
 
-#define mrb_immediate_p(o) ((o).w & BOXWORD_IMMEDIATE_MASK || (o).w == MRB_Qnil)
 #define mrb_fixnum_p(o) BOXWORD_SHIFT_VALUE_P(o, FIXNUM)
+#define mrb_integer_p(o) (BOXWORD_SHIFT_VALUE_P(o, FIXNUM)||BOXWORD_OBJ_TYPE_P(o, INTEGER))
 #ifdef MRB_64BIT
-#define mrb_symbol_p(o) ((o).value.sym_flag == BOXWORD_SYMBOL_FLAG)
+#define mrb_symbol_p(o) (mrb_val_union(o).sym_flag == BOXWORD_SYMBOL_FLAG)
 #else
 #define mrb_symbol_p(o) BOXWORD_SHIFT_VALUE_P(o, SYMBOL)
 #endif
-#define mrb_undef_p(o) ((o).w == MRB_Qundef)
-#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
-#define mrb_false_p(o) ((o).w == MRB_Qfalse)
-#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
-#ifndef MRB_WITHOUT_FLOAT
+#define mrb_undef_p(o) ((o) == MRB_Qundef)
+#define mrb_nil_p(o)  ((o) == MRB_Qnil)
+#define mrb_false_p(o) ((o) == MRB_Qfalse)
+#define mrb_true_p(o)  ((o) == MRB_Qtrue)
+#ifndef MRB_NO_FLOAT
 #define mrb_float_p(o) BOXWORD_OBJ_TYPE_P(o, FLOAT)
 #endif
 #define mrb_array_p(o) BOXWORD_OBJ_TYPE_P(o, ARRAY)
@@ -143,32 +160,38 @@ MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
 #define mrb_istruct_p(o) BOXWORD_OBJ_TYPE_P(o, ISTRUCT)
 #define mrb_break_p(o) BOXWORD_OBJ_TYPE_P(o, BREAK)
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
 #endif
 #define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_word_boxing_cptr_value(mrb, v))
-#define SET_UNDEF_VALUE(r) ((r).w = MRB_Qundef)
-#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
-#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
-#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
+#define SET_UNDEF_VALUE(r) ((r) = MRB_Qundef)
+#define SET_NIL_VALUE(r) ((r) = MRB_Qnil)
+#define SET_FALSE_VALUE(r) ((r) = MRB_Qfalse)
+#define SET_TRUE_VALUE(r) ((r) = MRB_Qtrue)
 #define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
-#define SET_INT_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n)
+#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_word_boxing_int_value(mrb, n))
+#define SET_FIXNUM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, FIXNUM, n)
 #ifdef MRB_64BIT
-#define SET_SYM_VALUE(r,v) ((r).value.sym = v, (r).value.sym_flag = BOXWORD_SYMBOL_FLAG)
+#define SET_SYM_VALUE(r,v) do {\
+  union mrb_value_ mrb_value_union_variable;\
+  mrb_value_union_variable.sym = v;\
+  mrb_value_union_variable.sym_flag = BOXWORD_SYMBOL_FLAG;\
+  (r) = mrb_value_union_variable.w;\
+} while (0)
 #else
 #define SET_SYM_VALUE(r,n) BOXWORD_SET_SHIFT_VALUE(r, SYMBOL, n)
 #endif
-#define SET_OBJ_VALUE(r,v) ((r).value.p = v)
+#define SET_OBJ_VALUE(r,v) ((r) = (uintptr_t)v)
 
 MRB_INLINE enum mrb_vtype
 mrb_type(mrb_value o)
 {
   return !mrb_bool(o)    ? MRB_TT_FALSE :
          mrb_true_p(o)   ? MRB_TT_TRUE :
-         mrb_fixnum_p(o) ? MRB_TT_FIXNUM :
+         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
          mrb_symbol_p(o) ? MRB_TT_SYMBOL :
          mrb_undef_p(o)  ? MRB_TT_UNDEF :
-         o.value.bp->tt;
+         mrb_val_union(o).bp->tt;
 }
 
 #endif  /* MRUBY_BOXING_WORD_H */
diff --git a/include/mruby/class.h b/include/mruby/class.h
index cbf96fef2..c88079e59 100644
--- a/include/mruby/class.h
+++ b/include/mruby/class.h
@@ -17,7 +17,7 @@ MRB_BEGIN_DECL
 struct RClass {
   MRB_OBJECT_HEADER;
   struct iv_tbl *iv;
-  struct kh_mt *mt;
+  struct mt_tbl *mt;
   struct RClass *super;
 };
 
@@ -35,9 +35,9 @@ mrb_class(mrb_state *mrb, mrb_value v)
     return mrb->true_class;
   case MRB_TT_SYMBOL:
     return mrb->symbol_class;
-  case MRB_TT_FIXNUM:
-    return mrb->fixnum_class;
-#ifndef MRB_WITHOUT_FLOAT
+  case MRB_TT_INTEGER:
+    return mrb->integer_class;
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
     return mrb->float_class;
 #endif
@@ -73,13 +73,11 @@ mrb_class(mrb_state *mrb, mrb_value v)
 #define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
 #define MRB_INSTANCE_TT(c) (enum mrb_vtype)((c)->flags & MRB_INSTANCE_TT_MASK)
 
-MRB_API struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
-MRB_API struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
 struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
 struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
 MRB_API void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, mrb_method_t);
-MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
 MRB_API void mrb_alias_method(mrb_state*, struct RClass *c, mrb_sym a, mrb_sym b);
+MRB_API void mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym sym);
 
 MRB_API mrb_method_t mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
 MRB_API mrb_method_t mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
@@ -95,12 +93,17 @@ void mrb_gc_mark_mt(mrb_state*, struct RClass*);
 size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
 void mrb_gc_free_mt(mrb_state*, struct RClass*);
 
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
 void mrb_mc_clear_by_class(mrb_state *mrb, struct RClass* c);
 #else
 #define mrb_mc_clear_by_class(mrb,c)
 #endif
 
+/* return non zero to break the loop */
+struct mt_elem;
+typedef int (mrb_mt_foreach_func)(mrb_state*,mrb_sym,struct mt_elem*,void*);
+MRB_API void mrb_mt_foreach(mrb_state*, struct RClass*, mrb_mt_foreach_func*, void*);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_CLASS_H */
diff --git a/include/mruby/compile.h b/include/mruby/compile.h
index e8ab91eb9..36adf5a32 100644
--- a/include/mruby/compile.h
+++ b/include/mruby/compile.h
@@ -33,7 +33,7 @@ typedef struct mrbc_context {
   mrb_bool no_exec:1;
   mrb_bool keep_lv:1;
   mrb_bool no_optimize:1;
-  struct RProc *upper;
+  const struct RProc *upper;
 
   size_t parser_nerr;
 } mrbc_context;
@@ -153,7 +153,7 @@ struct mrb_parser_state {
 
   mrb_bool no_optimize:1;
   mrb_bool capture_errors:1;
-  struct RProc *upper;
+  const struct RProc *upper;
   struct mrb_parser_message error_buffer[10];
   struct mrb_parser_message warn_buffer[10];
 
diff --git a/include/mruby/debug.h b/include/mruby/debug.h
index 5c5d56924..f22c7c77b 100644
--- a/include/mruby/debug.h
+++ b/include/mruby/debug.h
@@ -46,7 +46,7 @@ typedef struct mrb_irep_debug_info {
  * get line from irep's debug info and program counter
  * @return returns NULL if not found
  */
-MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc);
+MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t pc);
 
 /*
  * get line from irep's debug info and program counter
diff --git a/include/mruby/dump.h b/include/mruby/dump.h
index db3e287d3..90eaca184 100644
--- a/include/mruby/dump.h
+++ b/include/mruby/dump.h
@@ -18,10 +18,11 @@ MRB_BEGIN_DECL
 
 #define DUMP_DEBUG_INFO 1
 
-int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
+int mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
 #ifndef MRB_DISABLE_STDIO
-int mrb_dump_irep_binary(mrb_state*, mrb_irep*, uint8_t, FILE*);
-int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, uint8_t flags, FILE *f, const char *initname);
+int mrb_dump_irep_binary(mrb_state*, const mrb_irep*, uint8_t, FILE*);
+int mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname);
+int mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname);
 mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
 MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*);
 MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
@@ -48,11 +49,16 @@ MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
 
 /* Rite Binary File header */
 #define RITE_BINARY_IDENT              "RITE"
-#define RITE_BINARY_FORMAT_VER         "0007"
+/* Binary Format Version Major:Minor */
+/*   Major: Incompatible to prior versions */
+/*   Minor: Upper-compatible to prior versions */
+#define RITE_BINARY_MAJOR_VER          "01"
+#define RITE_BINARY_MINOR_VER          "00"
+#define RITE_BINARY_FORMAT_VER         RITE_BINARY_MAJOR_VER RITE_BINARY_MINOR_VER
 #define RITE_COMPILER_NAME             "MATZ"
 #define RITE_COMPILER_VERSION          "0000"
 
-#define RITE_VM_VER                    "0002"
+#define RITE_VM_VER                    "0300"
 
 #define RITE_BINARY_EOF                "END\0"
 #define RITE_SECTION_IREP_IDENT        "IREP"
@@ -65,7 +71,8 @@ MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
 /* binary header */
 struct rite_binary_header {
   uint8_t binary_ident[4];    /* Binary Identifier */
-  uint8_t binary_version[4];  /* Binary Format Version */
+  uint8_t major_version[2];   /* Binary Format Major Version */
+  uint8_t minor_version[2];   /* Binary Format Minor Version */
   uint8_t binary_crc[2];      /* Binary CRC */
   uint8_t binary_size[4];     /* Binary Size */
   uint8_t compiler_name[4];   /* Compiler name */
@@ -126,16 +133,6 @@ uint32_to_bin(uint32_t l, uint8_t *bin)
   return sizeof(uint32_t);
 }
 
-static inline size_t
-uint32l_to_bin(uint32_t l, uint8_t *bin)
-{
-  bin[3] = (l >> 24) & 0xff;
-  bin[2] = (l >> 16) & 0xff;
-  bin[1] = (l >> 8) & 0xff;
-  bin[0] = l & 0xff;
-  return sizeof(uint32_t);
-}
-
 static inline uint32_t
 bin_to_uint32(const uint8_t *bin)
 {
@@ -145,15 +142,6 @@ bin_to_uint32(const uint8_t *bin)
          (uint32_t)bin[3];
 }
 
-static inline uint32_t
-bin_to_uint32l(const uint8_t *bin)
-{
-  return (uint32_t)bin[3] << 24 |
-         (uint32_t)bin[2] << 16 |
-         (uint32_t)bin[1] << 8  |
-         (uint32_t)bin[0];
-}
-
 static inline uint16_t
 bin_to_uint16(const uint8_t *bin)
 {
diff --git a/include/mruby/endian.h b/include/mruby/endian.h
new file mode 100644
index 000000000..477f3bc94
--- /dev/null
+++ b/include/mruby/endian.h
@@ -0,0 +1,44 @@
+/**
+** @file mruby/endian.h - detect endian-ness
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ENDIAN_H
+#define MRUBY_ENDIAN_H
+
+#include <limits.h>
+
+MRB_BEGIN_DECL
+
+#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER__)
+# define BYTE_ORDER __BYTE_ORDER__
+#endif
+#if !defined(BIG_ENDIAN) && defined(__ORDER_BIG_ENDIAN__)
+# define BIG_ENDIAN __ORDER_BIG_ENDIAN__
+#endif
+#if !defined(LITTLE_ENDIAN) && defined(__ORDER_LITTLE_ENDIAN__)
+# define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__
+#endif
+
+#ifdef BYTE_ORDER
+# if BYTE_ORDER == BIG_ENDIAN
+#  define littleendian 0
+# elif BYTE_ORDER == LITTLE_ENDIAN
+#  define littleendian 1
+# endif
+#endif
+#ifndef littleendian
+/* can't distinguish endian in compile time */
+static inline int
+check_little_endian(void)
+{
+  unsigned int n = 1;
+  return (*(unsigned char *)&n == 1);
+}
+#  define littleendian check_little_endian()
+#endif
+
+MRB_END_DECL
+
+#endif  /* MRUBY_ENDIAN_H */
diff --git a/include/mruby/error.h b/include/mruby/error.h
index d24b5b0c3..9ad115f4b 100644
--- a/include/mruby/error.h
+++ b/include/mruby/error.h
@@ -23,7 +23,8 @@ struct RException {
 
 MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg);
 MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
-#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+#define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+#define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str_lit(mrb, c, lit)
 MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
 MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
 MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
@@ -32,10 +33,10 @@ MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_va
 /* declaration for `fail` method */
 MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
 
-#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING)
+#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING)
 struct RBreak {
   MRB_OBJECT_HEADER;
-  struct RProc *proc;
+  const struct RProc *proc;
   mrb_value val;
 };
 #define mrb_break_value_get(brk) ((brk)->val)
@@ -43,7 +44,7 @@ struct RBreak {
 #else
 struct RBreak {
   MRB_OBJECT_HEADER;
-  struct RProc *proc;
+  const struct RProc *proc;
   union mrb_value_union value;
 };
 #define RBREAK_VALUE_TT_MASK ((1 << 8) - 1)
@@ -62,10 +63,43 @@ mrb_break_value_set(struct RBreak *brk, mrb_value val)
   brk->flags &= ~RBREAK_VALUE_TT_MASK;
   brk->flags |= val.tt;
 }
-#endif  /* MRB_64BIT || MRB_USE_FLOAT || MRB_NAN_BOXING || MRB_WORD_BOXING */
+#endif  /* MRB_64BIT || MRB_USE_FLOAT32 || MRB_NAN_BOXING || MRB_WORD_BOXING */
 #define mrb_break_proc_get(brk) ((brk)->proc)
 #define mrb_break_proc_set(brk, p) ((brk)->proc = p)
 
+#define RBREAK_TAG_FOREACH(f) \
+  f(RBREAK_TAG_BREAK, 0) \
+  f(RBREAK_TAG_BREAK_UPPER, 1) \
+  f(RBREAK_TAG_BREAK_INTARGET, 2) \
+  f(RBREAK_TAG_RETURN_BLOCK, 3) \
+  f(RBREAK_TAG_RETURN, 4) \
+  f(RBREAK_TAG_RETURN_TOPLEVEL, 5) \
+  f(RBREAK_TAG_JUMP, 6) \
+  f(RBREAK_TAG_STOP, 7)
+
+#define RBREAK_TAG_DEFINE(tag, i) tag = i,
+enum {
+  RBREAK_TAG_FOREACH(RBREAK_TAG_DEFINE)
+};
+#undef RBREAK_TAG_DEFINE
+
+#define RBREAK_TAG_BIT          3
+#define RBREAK_TAG_BIT_OFF      8
+#define RBREAK_TAG_MASK         (~(~UINT32_C(0) << RBREAK_TAG_BIT))
+
+static inline uint32_t
+mrb_break_tag_get(struct RBreak *brk)
+{
+  return (brk->flags >> RBREAK_TAG_BIT_OFF) & RBREAK_TAG_MASK;
+}
+
+static inline void
+mrb_break_tag_set(struct RBreak *brk, uint32_t tag)
+{
+  brk->flags &= ~(RBREAK_TAG_MASK << RBREAK_TAG_BIT_OFF);
+  brk->flags |= (tag & RBREAK_TAG_MASK) << RBREAK_TAG_BIT_OFF;
+}
+
 /**
  * Protect
  *
diff --git a/include/mruby/hash.h b/include/mruby/hash.h
index 86fbe329d..7dab4a85c 100644
--- a/include/mruby/hash.h
+++ b/include/mruby/hash.h
@@ -201,7 +201,7 @@ MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2);
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)(mrb_ptr(obj)))
 #define RHASH_TBL(h)          (RHASH(h)->ht)
-#define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
+#define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), MRB_SYM(ifnone))
 #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
 
 #define MRB_HASH_DEFAULT      1
diff --git a/include/mruby/irep.h b/include/mruby/irep.h
index 661ef2b48..a9c20681c 100644
--- a/include/mruby/irep.h
+++ b/include/mruby/irep.h
@@ -16,28 +16,58 @@
 MRB_BEGIN_DECL
 
 enum irep_pool_type {
-  IREP_TT_STRING,
-  IREP_TT_FIXNUM,
-  IREP_TT_FLOAT,
+  IREP_TT_STR   = 0,          /* string (need free) */
+  IREP_TT_SSTR  = 2,          /* string (static) */
+  IREP_TT_INT32 = 1,          /* 32bit integer */
+  IREP_TT_INT64 = 3,          /* 64bit integer */
+  IREP_TT_FLOAT = 5,          /* float (double/float) */
 };
 
-struct mrb_locals {
-  mrb_sym name;
-  uint16_t r;
+#define IREP_TT_NFLAG 1       /* number (non string) flag */
+#define IREP_TT_SFLAG 2       /* static string flag */
+
+typedef struct mrb_pool_value {
+  uint32_t tt;     /* packed type and length (for string) */
+  union {
+    const char *str;
+    int32_t i32;
+#ifdef MRB_64BIT
+    int64_t i64;
+#endif
+    mrb_float f;
+  } u;
+} mrb_pool_value;
+
+enum mrb_catch_type {
+  MRB_CATCH_RESCUE = 0,
+  MRB_CATCH_ENSURE = 1,
+};
+
+struct mrb_irep_catch_handler {
+  uint8_t type;         /* enum mrb_catch_type */
+  uint8_t begin[2];     /* The starting address to match the hander. Includes this. */
+  uint8_t end[2];       /* The endpoint address that matches the hander. Not Includes this. */
+  uint8_t target[2];    /* The address to jump to if a match is made. */
 };
 
 /* Program data array struct */
 typedef struct mrb_irep {
   uint16_t nlocals;        /* Number of local variables */
   uint16_t nregs;          /* Number of register variables */
+  uint16_t clen;           /* Number of catch handlers */
   uint8_t flags;
 
   const mrb_code *iseq;
-  mrb_value *pool;
-  mrb_sym *syms;
-  struct mrb_irep **reps;
-
-  struct mrb_locals *lv;
+  /*
+   * A catch handler table is placed after the iseq entity.
+   * The reason it doesn't add fields to the structure is to keep the mrb_irep structure from bloating.
+   * The catch handler table can be obtained with `mrb_irep_catch_handler_table(irep)`.
+   */
+  const mrb_pool_value *pool;
+  const mrb_sym *syms;
+  const struct mrb_irep * const *reps;
+
+  const mrb_sym *lv;
   /* debug info */
   struct mrb_irep_debug_info* debug_info;
 
@@ -46,6 +76,8 @@ typedef struct mrb_irep {
 } mrb_irep;
 
 #define MRB_ISEQ_NO_FREE 1
+#define MRB_IREP_NO_FREE 2
+#define MRB_IREP_STATIC  (MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE)
 
 MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
 
@@ -92,6 +124,17 @@ struct mrb_insn_data {
 
 struct mrb_insn_data mrb_decode_insn(const mrb_code *pc);
 
+static inline const struct mrb_irep_catch_handler *
+mrb_irep_catch_handler_table(const struct mrb_irep *irep)
+{
+  if (irep->clen > 0) {
+    return (const struct mrb_irep_catch_handler*)(irep->iseq + irep->ilen);
+  }
+  else {
+    return (const struct mrb_irep_catch_handler*)NULL;
+  }
+}
+
 MRB_END_DECL
 
 #endif  /* MRUBY_IREP_H */
diff --git a/include/mruby/numeric.h b/include/mruby/numeric.h
index 06a33cc6f..7e70b9dee 100644
--- a/include/mruby/numeric.h
+++ b/include/mruby/numeric.h
@@ -1,5 +1,5 @@
 /**
-** @file mruby/numeric.h - Numeric, Integer, Float, Fixnum class
+** @file mruby/numeric.h - Numeric, Integer, Float class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -12,17 +12,17 @@
 /**
  * Numeric class and it's sub-classes.
  *
- * Integer, Float and Fixnum
+ * Integer and Float
  */
 MRB_BEGIN_DECL
 
-#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_INT_MAX)
-#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_INT_MIN)
+#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
+#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
 #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
 #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
 #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
 #define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #ifdef MRB_INT64
 #define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
 #else
@@ -30,16 +30,15 @@ MRB_BEGIN_DECL
 #endif
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
 #endif
 MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
 /* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
 MRB_API int mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float f);
 MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
-MRB_API mrb_value mrb_int_value(mrb_state *mrb, mrb_float f);
 #endif
 
 MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y);
@@ -137,15 +136,15 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
     if (multiplicand > 0) {
       if (multiplier > MRB_INT_MAX / multiplicand) return TRUE;
     }
-    else {
+    else if (multiplicand < 0) {
       if (multiplicand < MRB_INT_MAX / multiplier) return TRUE;
     }
   }
-  else {
+  else if (multiplier < 0) {
     if (multiplicand > 0) {
       if (multiplier < MRB_INT_MAX / multiplicand) return TRUE;
     }
-    else {
+    else if (multiplicand < 0) {
       if (multiplier != 0 && multiplicand < MRB_INT_MAX / multiplier) return TRUE;
     }
   }
@@ -161,13 +160,13 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 # include <stdint.h>
 # include <float.h>
 
 # define MRB_FLT_RADIX          FLT_RADIX
 
-# ifdef MRB_USE_FLOAT
+# ifdef MRB_USE_FLOAT32
 #  define MRB_FLT_MANT_DIG      FLT_MANT_DIG
 #  define MRB_FLT_EPSILON       FLT_EPSILON
 #  define MRB_FLT_DIG           FLT_DIG
@@ -178,7 +177,7 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 #  define MRB_FLT_MAX           FLT_MAX
 #  define MRB_FLT_MAX_10_EXP    FLT_MAX_10_EXP
 
-# else /* not MRB_USE_FLOAT */
+# else /* not MRB_USE_FLOAT32 */
 #  define MRB_FLT_MANT_DIG      DBL_MANT_DIG
 #  define MRB_FLT_EPSILON       DBL_EPSILON
 #  define MRB_FLT_DIG           DBL_DIG
@@ -188,8 +187,8 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 #  define MRB_FLT_MAX_EXP       DBL_MAX_EXP
 #  define MRB_FLT_MAX           DBL_MAX
 #  define MRB_FLT_MAX_10_EXP    DBL_MAX_10_EXP
-# endif /* MRB_USE_FLOAT */
-#endif /* MRB_WITHOUT_FLOAT */
+# endif /* MRB_USE_FLOAT32 */
+#endif /* MRB_NO_FLOAT */
 
 MRB_END_DECL
 
diff --git a/include/mruby/opcode.h b/include/mruby/opcode.h
index 95e6736a4..a6c636cf8 100644
--- a/include/mruby/opcode.h
+++ b/include/mruby/opcode.h
@@ -39,31 +39,4 @@ enum mrb_insn {
 #define FETCH_S() do {a=READ_S();} while (0)
 #define FETCH_W() do {a=READ_W();} while (0)
 
-/* with OP_EXT1 (1st 16bit) */
-#define FETCH_Z_1() FETCH_Z()
-#define FETCH_B_1() FETCH_S()
-#define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
-#define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
-#define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_1() FETCH_S()
-#define FETCH_W_1() FETCH_W()
-
-/* with OP_EXT2 (2nd 16bit) */
-#define FETCH_Z_2() FETCH_Z()
-#define FETCH_B_2() FETCH_B()
-#define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
-#define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_2() FETCH_BS()
-#define FETCH_S_2() FETCH_S()
-#define FETCH_W_2() FETCH_W()
-
-/* with OP_EXT3 (1st & 2nd 16bit) */
-#define FETCH_Z_3() FETCH_Z()
-#define FETCH_B_3() FETCH_B()
-#define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_3() FETCH_S()
-#define FETCH_W_3() FETCH_W()
-
 #endif  /* MRUBY_OPCODE_H */
diff --git a/include/mruby/ops.h b/include/mruby/ops.h
index e85ee3133..75936a791 100644
--- a/include/mruby/ops.h
+++ b/include/mruby/ops.h
@@ -25,6 +25,7 @@ OPCODE(LOADI_4,    B)        /* R(a) = mrb_int(4) */
 OPCODE(LOADI_5,    B)        /* R(a) = mrb_int(5) */
 OPCODE(LOADI_6,    B)        /* R(a) = mrb_int(6) */
 OPCODE(LOADI_7,    B)        /* R(a) = mrb_int(7) */
+OPCODE(LOADI16,    BS)       /* R(a) = mrb_int(b) */
 OPCODE(LOADSYM,    BB)       /* R(a) = Syms(b) */
 OPCODE(LOADNIL,    B)        /* R(a) = nil */
 OPCODE(LOADSELF,   B)        /* R(a) = self */
@@ -48,13 +49,10 @@ OPCODE(JMP,        S)        /* pc=a */
 OPCODE(JMPIF,      BS)       /* if R(a) pc=b */
 OPCODE(JMPNOT,     BS)       /* if !R(a) pc=b */
 OPCODE(JMPNIL,     BS)       /* if R(a)==nil pc=b */
-OPCODE(ONERR,      S)        /* rescue_push(a) */
+OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
 OPCODE(EXCEPT,     B)        /* R(a) = exc */
 OPCODE(RESCUE,     BB)       /* R(b) = R(a).isa?(R(b)) */
-OPCODE(POPERR,     B)        /* a.times{rescue_pop()} */
-OPCODE(RAISE,      B)        /* raise(R(a)) */
-OPCODE(EPUSH,      B)        /* ensure_push(SEQ[a]) */
-OPCODE(EPOP,       B)        /* A.times{ensure_pop().call} */
+OPCODE(RAISEIF,    B)        /* raise(R(a)) if R(a) */
 OPCODE(SENDV,      BB)       /* R(a) = call(R(a),Syms(b),*R(a+1)) */
 OPCODE(SENDVB,     BB)       /* R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) */
 OPCODE(SEND,       BBB)      /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) */
@@ -111,8 +109,4 @@ OPCODE(SCLASS,     B)        /* R(a) = R(a).singleton_class */
 OPCODE(TCLASS,     B)        /* R(a) = target_class */
 OPCODE(DEBUG,      BBB)      /* print a,b,c */
 OPCODE(ERR,        B)        /* raise(LocalJumpError, Lit(a)) */
-OPCODE(EXT1,       Z)        /* make 1st operand 16bit */
-OPCODE(EXT2,       Z)        /* make 2nd operand 16bit */
-OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
 OPCODE(STOP,       Z)        /* stop VM */
-OPCODE(LOADI16,    BS)       /* R(a) = mrb_int(b) */
diff --git a/include/mruby/presym.h b/include/mruby/presym.h
new file mode 100644
index 000000000..3cc12e8fb
--- /dev/null
+++ b/include/mruby/presym.h
@@ -0,0 +1,25 @@
+/**
+** @file mruby/presym.h - Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_H
+#define MRUBY_PRESYM_H
+
+#undef MRB_PRESYM_MAX
+#define MRB_PRESYM_CSYM(sym, num) MRB_PRESYM__##sym = (num<<1),
+#define MRB_PRESYM_QSYM(str, sym, num) MRB_PRESYM_q_##sym = (num<<1),
+#define MRB_PRESYM_SYM(sym, num) 
+
+enum mruby_presym {
+#include <../build/presym.inc>
+};
+
+#undef MRB_PRESYM_CSYM
+#undef MRB_PRESYM_QSYM
+#undef MRB_PRESYM_SYM
+
+#define MRB_SYM(sym) MRB_PRESYM__##sym
+#define MRB_QSYM(sym) MRB_PRESYM_q_##sym
+#endif  /* MRUBY_PRESYM_H */
diff --git a/include/mruby/proc.h b/include/mruby/proc.h
index 12013c3ae..981e1111d 100644
--- a/include/mruby/proc.h
+++ b/include/mruby/proc.h
@@ -41,10 +41,10 @@ void mrb_env_unshare(mrb_state*, struct REnv*);
 struct RProc {
   MRB_OBJECT_HEADER;
   union {
-    mrb_irep *irep;
+    const mrb_irep *irep;
     mrb_func_t func;
   } body;
-  struct RProc *upper;
+  const struct RProc *upper;
   union {
     struct RClass *target_class;
     struct REnv *env;
@@ -57,7 +57,7 @@ struct RProc {
 #define MRB_ASPEC_REST(a)         (((a) >> 12) & 0x1)
 #define MRB_ASPEC_POST(a)         (((a) >> 7) & 0x1f)
 #define MRB_ASPEC_KEY(a)          (((a) >> 2) & 0x1f)
-#define MRB_ASPEC_KDICT(a)        ((a) & (1<<1))
+#define MRB_ASPEC_KDICT(a)        (((a) >> 1) & 0x1)
 #define MRB_ASPEC_BLOCK(a)        ((a) & 1)
 
 #define MRB_PROC_CFUNC_FL 128
@@ -86,16 +86,13 @@ struct RProc {
 
 #define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
 
-struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
-struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
+struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*);
+struct RProc *mrb_closure_new(mrb_state*, const mrb_irep*);
 MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
 MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
 void mrb_proc_copy(struct RProc *a, struct RProc *b);
 mrb_int mrb_proc_arity(const struct RProc *p);
 
-/* implementation of #send method */
-mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
-
 /* following functions are defined in mruby-proc-ext so please include it when using */
 MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv);
 MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
@@ -104,7 +101,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
 
 #define MRB_METHOD_FUNC_FL 1
 #define MRB_METHOD_NOARG_FL 2
-#ifndef MRB_METHOD_T_STRUCT
+
+#ifndef MRB_USE_METHOD_T_STRUCT
 
 #define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
 #define MRB_METHOD_NOARG_P(m) (((uintptr_t)(m))&MRB_METHOD_NOARG_FL)
@@ -128,7 +126,7 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
 #define MRB_METHOD_PROC(m) ((m).proc)
 #define MRB_METHOD_UNDEF_P(m) ((m).proc==NULL)
 
-#endif /* MRB_METHOD_T_STRUCT */
+#endif /* MRB_USE_METHOD_T_STRUCT */
 
 #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
 #define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
@@ -137,6 +135,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
 #include <mruby/khash.h>
 KHASH_DECLARE(mt, mrb_sym, mrb_method_t, TRUE)
 
+MRB_API mrb_value mrb_load_proc(mrb_state *mrb, const struct RProc *proc);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_PROC_H */
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 93c94ef5d..8384128c7 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -35,7 +35,7 @@ struct RString {
 };
 struct RStringEmbed {
   MRB_OBJECT_HEADER;
-  char ary[];
+  char ary[RSTRING_EMBED_LEN_MAX+1];
 };
 
 #define RSTR_SET_TYPE_FLAG(s, type) (RSTR_UNSET_TYPE_FLAG(s), (s)->flags |= MRB_STR_##type)
@@ -92,9 +92,6 @@ struct RStringEmbed {
 # define RSTR_COPY_ASCII_FLAG(dst, src) (void)0
 #endif
 
-#define RSTR_POOL_P(s) ((s)->flags & MRB_STR_POOL)
-#define RSTR_SET_POOL_FLAG(s) ((s)->flags |= MRB_STR_POOL)
-
 /**
  * Returns a pointer from a Ruby string
  */
@@ -112,13 +109,11 @@ MRB_API mrb_int mrb_str_strlen(mrb_state*, struct RString*);
 #define MRB_STR_FSHARED   2
 #define MRB_STR_NOFREE    4
 #define MRB_STR_EMBED     8  /* type flags up to here */
-#define MRB_STR_POOL     16  /* status flags from here */
-#define MRB_STR_ASCII    32
+#define MRB_STR_ASCII    16
 #define MRB_STR_EMBED_LEN_SHIFT 6
 #define MRB_STR_EMBED_LEN_BIT 5
 #define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BIT) - 1) << MRB_STR_EMBED_LEN_SHIFT)
-#define MRB_STR_TYPE_MASK (MRB_STR_POOL - 1)
-
+#define MRB_STR_TYPE_MASK 15
 
 void mrb_gc_free_str(mrb_state*, struct RString*);
 
@@ -382,8 +377,9 @@ MRB_API double mrb_cstr_to_dbl(mrb_state *mrb, const char *s, mrb_bool badcheck)
 /**
  * Returns a converted string type.
  * For type checking, non converting `mrb_to_str` is recommended.
+ * obsolete: use `mrb_obj_as_string()` instead.
  */
-MRB_API mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
+#define mrb_str_to_str(mrb, str) mrb_obj_as_string(mrb, str)
 
 /**
  * Returns true if the strings match and false if the strings don't match.
@@ -447,7 +443,6 @@ MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
  */
 MRB_API char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str);
 
-mrb_value mrb_str_pool(mrb_state *mrb, const char *s, mrb_int len, mrb_bool nofree);
 uint32_t mrb_str_hash(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
 
diff --git a/include/mruby/throw.h b/include/mruby/throw.h
index 1f1298d7d..b5ea7312e 100644
--- a/include/mruby/throw.h
+++ b/include/mruby/throw.h
@@ -13,7 +13,9 @@
 # endif
 #endif
 
-#if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
+#if defined(MRB_ENABLE_CXX_EXCEPTION)
+
+# if defined(__cplusplus)
 
 #define MRB_TRY(buf) try {
 #define MRB_CATCH(buf) } catch(mrb_jmpbuf_impl e) { if (e != (buf)->impl) { throw e; }
@@ -22,6 +24,10 @@
 #define MRB_THROW(buf) throw((buf)->impl)
 typedef mrb_int mrb_jmpbuf_impl;
 
+# else
+# error "need to be compiled with C++ compiler"
+# endif  /* __cplusplus */
+
 #else
 
 #include <setjmp.h>
@@ -46,9 +52,11 @@ typedef mrb_int mrb_jmpbuf_impl;
 struct mrb_jmpbuf {
   mrb_jmpbuf_impl impl;
 
-#if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
+#if defined(MRB_ENABLE_CXX_EXCEPTION)
   static mrb_int jmpbuf_id;
+# if defined(__cplusplus)
   mrb_jmpbuf() : impl(jmpbuf_id++) {}
+# endif
 #endif
 };
 
diff --git a/include/mruby/value.h b/include/mruby/value.h
index 473774b00..698c83300 100644
--- a/include/mruby/value.h
+++ b/include/mruby/value.h
@@ -54,16 +54,20 @@ struct mrb_state;
 #if defined(MRB_INT64)
   typedef int64_t mrb_int;
 # define MRB_INT_BIT 64
-# define MRB_INT_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
+# define MRB_INT_MIN INT64_MIN
+# define MRB_INT_MAX INT64_MAX
+# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
 # define MRB_PRIo PRIo64
 # define MRB_PRId PRId64
 # define MRB_PRIx PRIx64
 #else
   typedef int32_t mrb_int;
 # define MRB_INT_BIT 32
-# define MRB_INT_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
-# define MRB_INT_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
+# define MRB_INT_MIN INT32_MIN
+# define MRB_INT_MAX INT32_MAX
+# define MRB_FIXNUM_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
 # define MRB_PRIo PRIo32
 # define MRB_PRId PRId32
 # define MRB_PRIx PRIx32
@@ -75,9 +79,9 @@ struct mrb_state;
 # define MRB_ENDIAN_LOHI(a,b) b a
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API double mrb_float_read(const char*, char**);
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
   typedef float mrb_float;
 #else
   typedef double mrb_float;
@@ -90,7 +94,7 @@ MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list ar
 MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...);
 # define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg)
 # define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__)
-# if _MSC_VER < 1800 && !defined MRB_WITHOUT_FLOAT
+# if _MSC_VER < 1800 && !defined MRB_NO_FLOAT
 #  include <float.h>
 #  define isfinite(n) _finite(n)
 #  define isnan _isnan
@@ -106,7 +110,7 @@ enum mrb_vtype {
   MRB_TT_FALSE = 0,
   MRB_TT_TRUE,
   MRB_TT_FLOAT,
-  MRB_TT_FIXNUM,
+  MRB_TT_INTEGER,
   MRB_TT_SYMBOL,
   MRB_TT_UNDEF,
   MRB_TT_CPTR,
@@ -130,6 +134,9 @@ enum mrb_vtype {
   MRB_TT_MAXDEFINE
 };
 
+/* for compatibility */
+#define MRB_TT_FIXNUM MRB_TT_INTEGER
+
 #include <mruby/object.h>
 
 #ifdef MRB_DOCUMENTATION_BLOCK
@@ -177,8 +184,11 @@ struct RCptr {
 #ifndef mrb_immediate_p
 #define mrb_immediate_p(o) (mrb_type(o) < MRB_TT_FREE)
 #endif
+#ifndef mrb_integer_p
+#define mrb_integer_p(o) (mrb_type(o) == MRB_TT_INTEGER)
+#endif
 #ifndef mrb_fixnum_p
-#define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM)
+#define mrb_fixnum_p(o) mrb_integer_p(o)
 #endif
 #ifndef mrb_symbol_p
 #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
@@ -195,7 +205,7 @@ struct RCptr {
 #ifndef mrb_true_p
 #define mrb_true_p(o)  (mrb_type(o) == MRB_TT_TRUE)
 #endif
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #ifndef mrb_float_p
 #define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
 #endif
@@ -264,7 +274,7 @@ struct RCptr {
  *
  * Takes a float and boxes it into an mrb_value
  */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_INLINE mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f)
 {
   mrb_value v;
@@ -284,14 +294,19 @@ mrb_cptr_value(struct mrb_state *mrb, void *p)
 }
 
 /**
- * Returns a fixnum in Ruby.
- *
- * Takes an integer and boxes it into an mrb_value
+ * Returns an integer in Ruby.
  */
+MRB_INLINE mrb_value mrb_int_value(struct mrb_state *mrb, mrb_int i)
+{
+  mrb_value v;
+  SET_INT_VALUE(mrb, v, i);
+  return v;
+}
+
 MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i)
 {
   mrb_value v;
-  SET_INT_VALUE(v, i);
+  SET_FIXNUM_VALUE(v, i);
   return v;
 }
 
diff --git a/lib/mruby/build.rb b/lib/mruby/build.rb
index 9ba136cf3..fa3853342 100644
--- a/lib/mruby/build.rb
+++ b/lib/mruby/build.rb
@@ -81,7 +81,8 @@ module MRuby
         @mrbc = Command::Mrbc.new(self)
 
         @bins = []
-        @gems, @libmruby_objs = MRuby::Gem::List.new, []
+        @gems = MRuby::Gem::List.new
+        @libmruby_objs = []
         @build_mrbtest_lib_only = false
         @cxx_exception_enabled = false
         @cxx_exception_disabled = false
@@ -95,11 +96,10 @@ module MRuby
         MRuby.targets[@name] = self
       end
 
-      MRuby::Build.current = MRuby.targets[@name]
-      MRuby.targets[@name].instance_eval(&block)
-
-      build_mrbc_exec if name == 'host'
-      build_mrbtest if test_enabled?
+      current = MRuby.targets[@name]
+      MRuby::Build.current = current
+      current.instance_eval(&block)
+      current.build_mrbtest if current.test_enabled?
     end
 
     def debug_enabled?
@@ -196,6 +196,7 @@ EOS
     end
 
     def enable_bintest
+      raise "bintest works only on 'host' target" unless name == "host"
       @enable_bintest = true
     end
 
@@ -246,9 +247,11 @@ EOS
     def mrbcfile
       return @mrbcfile if @mrbcfile
 
-      mrbc_build = MRuby.targets['host']
-      gems.each { |v| mrbc_build = self if v.name == 'mruby-bin-mrbc' }
-      @mrbcfile = mrbc_build.exefile("#{mrbc_build.build_dir}/bin/mrbc")
+      unless gems.detect {|v| v.name == 'mruby-bin-mrbc' }
+        build_mrbc_exec
+        gems.detect {|v| v.name == 'mruby-bin-mrbc' }.setup
+      end
+      @mrbcfile = self.exefile("#{self.build_dir}/bin/mrbc")
     end
 
     def compilers
@@ -369,13 +372,25 @@ EOS
     attr_accessor :host_target, :build_target
 
     def initialize(name, build_dir=nil, &block)
+      unless MRuby.targets['host']
+        # add minimal 'host'
+        MRuby::Build.new('host') do |conf|
+          if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+            toolchain :visualcpp
+          else
+            toolchain :gcc
+          end
+          conf.gem :core => 'mruby-bin-mrbc'
+        end
+      end
       @endian = nil
       @test_runner = Command::CrossTestRunner.new(self)
       super
     end
 
     def mrbcfile
-      MRuby.targets['host'].exefile("#{MRuby.targets['host'].build_dir}/bin/mrbc")
+      host = MRuby.targets['host']
+      host.exefile("#{host.build_dir}/bin/mrbc")
     end
 
     def run_test
diff --git a/lib/mruby/build/command.rb b/lib/mruby/build/command.rb
index 84ce78cb9..3d47c304f 100644
--- a/lib/mruby/build/command.rb
+++ b/lib/mruby/build/command.rb
@@ -313,13 +313,13 @@ module MRuby
       @compile_options = "-B%{funcname} -o-"
     end
 
-    def run(out, infiles, funcname)
+    def run(out, infiles, funcname, cdump = true)
       @command ||= @build.mrbcfile
       infiles = [infiles].flatten
       infiles.each do |f|
         _pp "MRBC", f.relative_path, nil, :indent => 2
       end
-      cmd = %Q["#{filename @command}" #{@compile_options % {:funcname => funcname}} #{filename(infiles).map{|f| %Q["#{f}"]}.join(' ')}]
+      cmd = %Q["#{filename @command}" #{cdump ? "-S" : ""} #{@compile_options % {:funcname => funcname}} #{filename(infiles).map{|f| %Q["#{f}"]}.join(' ')}]
       puts cmd if Rake.verbose
       IO.popen(cmd, 'r+') do |io|
         out.puts io.read
diff --git a/lib/mruby/build/load_gems.rb b/lib/mruby/build/load_gems.rb
index 522b8a17e..4f5bde7af 100644
--- a/lib/mruby/build/load_gems.rb
+++ b/lib/mruby/build/load_gems.rb
@@ -28,18 +28,19 @@ module MRuby
       Gem.current = nil
       load gemrake
       return nil unless Gem.current
+      current = Gem.current
 
-      Gem.current.dir = gemdir
-      Gem.current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current
-      Gem.current.build_config_initializer = block
-      gems << Gem.current
+      current.dir = gemdir
+      current.build = self.is_a?(MRuby::Build) ? self : MRuby::Build.current
+      current.build_config_initializer = block
+      gems << current
 
       cxx_srcs = ['src', 'test', 'tools'].map do |subdir|
-        Dir.glob("#{Gem.current.dir}/#{subdir}/*.{cpp,cxx,cc}")
+        Dir.glob("#{current.dir}/#{subdir}/*.{cpp,cxx,cc}")
       end.flatten
       enable_cxx_exception unless cxx_srcs.empty?
 
-      Gem.current
+      current
     end
 
     def load_special_path_gem(params)
diff --git a/lib/mruby/gem.rb b/lib/mruby/gem.rb
index 6fcaad9c1..d4b43b094 100644
--- a/lib/mruby/gem.rb
+++ b/lib/mruby/gem.rb
@@ -47,12 +47,14 @@ module MRuby
         @version = "0.0.0"
         @mrblib_dir = "mrblib"
         @objs_dir = "src"
+        @dependencies = []
+        @conflicts = []
         MRuby::Gem.current = self
       end
 
       def setup
         return if defined?(@linker)  # return if already set up
-
+        
         MRuby::Gem.current = self
         MRuby::Build::COMMANDS.each do |command|
           instance_variable_set("@#{command}", @build.send(command).clone)
@@ -75,7 +77,6 @@ module MRuby
         @bins = []
 
         @requirements = []
-        @dependencies, @conflicts = [], []
         @export_include_paths = []
         @export_include_paths << "#{dir}/include" if File.directory? "#{dir}/include"
 
@@ -174,7 +175,7 @@ module MRuby
       def generate_gem_init(fname)
         open(fname, 'w') do |f|
           print_gem_init_header f
-          build.mrbc.run f, rbfiles, "gem_mrblib_irep_#{funcname}" unless rbfiles.empty?
+          build.mrbc.run f, rbfiles, "gem_mrblib_#{funcname}_proc" unless rbfiles.empty?
           f.puts %Q[void mrb_#{funcname}_gem_init(mrb_state *mrb);]
           f.puts %Q[void mrb_#{funcname}_gem_final(mrb_state *mrb);]
           f.puts %Q[]
@@ -183,7 +184,7 @@ module MRuby
           f.puts %Q[  struct REnv *e;] unless rbfiles.empty?
           f.puts %Q[  mrb_#{funcname}_gem_init(mrb);] if objs != [objfile("#{build_dir}/gem_init")]
           unless rbfiles.empty?
-            f.puts %Q[  mrb_load_irep(mrb, gem_mrblib_irep_#{funcname});]
+            f.puts %Q[  mrb_load_proc(mrb, gem_mrblib_#{funcname}_proc);]
             f.puts %Q[  if (mrb->exc) {]
             f.puts %Q[    mrb_print_error(mrb);]
             f.puts %Q[    mrb_close(mrb);]
@@ -215,10 +216,13 @@ module MRuby
 
       def print_gem_init_header(f)
         print_gem_comment(f)
-        f.puts %Q[#include <stdlib.h>] unless rbfiles.empty?
-        f.puts %Q[#include <mruby.h>]
-        f.puts %Q[#include <mruby/irep.h>] unless rbfiles.empty?
-        f.puts %Q[#include <mruby/proc.h>] unless rbfiles.empty?
+        unless rbfiles.empty?
+          f.puts %Q[#include <stdlib.h>]
+          f.puts %Q[#include <mruby.h>]
+          f.puts %Q[#include <mruby/proc.h>]
+        else
+          f.puts %Q[#include <mruby.h>]
+        end
       end
 
       def print_gem_test_header(f)
@@ -226,7 +230,7 @@ module MRuby
         f.puts %Q[#include <stdio.h>]
         f.puts %Q[#include <stdlib.h>]
         f.puts %Q[#include <mruby.h>]
-        f.puts %Q[#include <mruby/irep.h>]
+        f.puts %Q[#include <mruby/proc.h>]
         f.puts %Q[#include <mruby/variable.h>]
         f.puts %Q[#include <mruby/hash.h>] unless test_args.empty?
       end
diff --git a/lib/mruby/lockfile.rb b/lib/mruby/lockfile.rb
index 0d2455b4c..5d4313649 100644
--- a/lib/mruby/lockfile.rb
+++ b/lib/mruby/lockfile.rb
@@ -26,7 +26,7 @@ module MRuby
       end
 
       def instance
-        @instance ||= new("#{MRUBY_CONFIG}.lock")
+        @instance ||= new("#{MRUBY_ROOT}/build/#{MRUBY_TARGET}.lock")
       end
     end
 
@@ -39,7 +39,7 @@ module MRuby
     end
 
     def write
-      locks = {"mruby_version" => mruby}
+      locks = {"mruby" => mruby}
       locks["builds"] = @builds if @builds
       File.write(@filename, YAML.dump(locks))
     end
diff --git a/mrbgems/default.gembox b/mrbgems/default.gembox
index de1e9a573..de169906b 100644
--- a/mrbgems/default.gembox
+++ b/mrbgems/default.gembox
@@ -5,6 +5,9 @@ MRuby::GemBox.new do |conf|
   # Use standard IO/File class
   conf.gem :core => "mruby-io"
 
+  # Use standard IO/File class
+  conf.gem :core => "mruby-socket"
+
   # Use standard Array#pack, String#unpack methods
   conf.gem :core => "mruby-pack"
 
@@ -84,6 +87,9 @@ MRuby::GemBox.new do |conf|
   # Generate mruby-strip command
   conf.gem :core => "mruby-bin-strip"
 
+  # Generate mruby-config command
+  conf.gem :core => "mruby-bin-config"
+
   # Use Kernel module extension
   conf.gem :core => "mruby-kernel-ext"
 
diff --git a/mrbgems/mruby-array-ext/src/array.c b/mrbgems/mruby-array-ext/src/array.c
index 3ce5d822e..9d7f1b28a 100644
--- a/mrbgems/mruby-array-ext/src/array.c
+++ b/mrbgems/mruby-array-ext/src/array.c
@@ -148,11 +148,11 @@ mrb_ary_slice_bang(mrb_state *mrb, mrb_value self)
       else {
         return mrb_nil_value();
       }
-    case MRB_TT_FIXNUM:
-      val = mrb_funcall(mrb, self, "delete_at", 1, index);
+    case MRB_TT_INTEGER:
+      val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index);
       return val;
     default:
-      val = mrb_funcall(mrb, self, "delete_at", 1, index);
+      val = mrb_funcall_id(mrb, self, MRB_SYM(delete_at), 1, index);
       return val;
     }
   }
diff --git a/mrbgems/mruby-bin-debugger/bintest/print.rb b/mrbgems/mruby-bin-debugger/bintest/print.rb
index a8401963f..653be0ce6 100644
--- a/mrbgems/mruby-bin-debugger/bintest/print.rb
+++ b/mrbgems/mruby-bin-debugger/bintest/print.rb
@@ -516,7 +516,7 @@ SRC
   tc << {:cmd=>'p a+1',   :exp=>'$1 = 2'}
   tc << {:cmd=>'p 2-b',   :exp=>'$2 = -3'}
   tc << {:cmd=>'p c * 3', :exp=>'$3 = 24'}
-  tc << {:cmd=>'p a/b',   :exp=>'$4 = 0.2'}
+  tc << {:cmd=>'p a/b',   :exp=>'$4 = 0'}
   tc << {:cmd=>'p c%b',   :exp=>'$5 = 3'}
   tc << {:cmd=>'p 2**10', :exp=>'$6 = 1024'}
   tc << {:cmd=>'p ~3',    :exp=>'$7 = -4'}
@@ -614,13 +614,13 @@ SRC
   tc << {:cmd=>'p a+=9',   :exp=>'$1 = 10'}
   tc << {:cmd=>'p b-=c',   :exp=>'$2 = 15'}
   tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'}
-  tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2.5'}
+  tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2'}
   tc << {:cmd=>'p c%=4',   :exp=>'$5 = 2'}
 
   tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'}
   tc << {:cmd=>'p c|=0x10',   :exp=>'$7 = 18'}
 
-  tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2.5 5 18"'}
+  tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2 5 18"'}
   tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'}
 
   tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'}
@@ -682,13 +682,13 @@ SRC
   tc << {:cmd=>'p a+=9',   :exp=>'$1 = 10'}
   tc << {:cmd=>'p b-=c',   :exp=>'$2 = 15'}
   tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'}
-  tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2.5'}
+  tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2'}
   tc << {:cmd=>'p c%=4',   :exp=>'$5 = 2'}
 
   tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'}
   tc << {:cmd=>'p c|=0x10',   :exp=>'$7 = 18'}
 
-  tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2.5 5 18"'}
+  tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2 5 18"'}
   tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'}
 
   tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'}
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
index ceeb27393..1507926f2 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apibreak.c
@@ -84,7 +84,7 @@ free_breakpoint(mrb_state *mrb, mrb_debug_breakpoint *bp)
 }
 
 static uint16_t
-check_file_lineno(mrb_state *mrb, struct mrb_irep *irep, const char *file, uint16_t lineno)
+check_file_lineno(mrb_state *mrb, const struct mrb_irep *irep, const char *file, uint16_t lineno)
 {
   mrb_irep_debug_info_file *info_file;
   uint16_t result = 0;
@@ -151,7 +151,7 @@ compare_break_method(mrb_state *mrb, mrb_debug_breakpoint *bp, struct RClass *cl
       }
 
       sc = mrb_class_get(mrb, method_p->class_name);
-      ssym = mrb_symbol(mrb_check_intern_cstr(mrb, method_p->method_name));
+      ssym = mrb_intern_check_cstr(mrb, method_p->method_name);
       m = mrb_method_search_vm(mrb, &sc, ssym);
       if (MRB_METHOD_UNDEF_P(m)) {
         return MRB_DEBUG_OK;
@@ -428,7 +428,7 @@ mrb_debug_disable_break_all(mrb_state *mrb, mrb_debug_context *dbg)
 }
 
 static mrb_bool
-check_start_pc_for_line(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, uint16_t line)
+check_start_pc_for_line(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, uint16_t line)
 {
   if (pc > irep->iseq) {
     if (line == mrb_debug_get_line(mrb, irep, pc - irep->iseq - 1)) {
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
index e8702f4df..e18dbcbfc 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/apiprint.c
@@ -33,7 +33,7 @@ mrdb_check_syntax(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size
 mrb_value
 mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t len, mrb_bool *exc, int direct_eval)
 {
-  void (*tmp)(struct mrb_state *, struct mrb_irep *, const mrb_code *, mrb_value *);
+  void (*tmp)(struct mrb_state *, const struct mrb_irep *, const mrb_code *, mrb_value *);
   mrb_value ruby_code;
   mrb_value s;
   mrb_value v;
@@ -67,7 +67,7 @@ mrb_debug_eval(mrb_state *mrb, mrb_debug_context *dbg, const char *expr, size_t
 
     recv = dbg->regs[0];
 
-    v =  mrb_funcall(mrb, recv, "instance_eval", 1, ruby_code);
+    v =  mrb_funcall_id(mrb, recv, MRB_SYM(instance_eval), 1, ruby_code);
   }
 
   if (exc) {
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
index 8fab3c2e8..f55e443fe 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.c
@@ -504,7 +504,7 @@ get_and_parse_command(mrb_state *mrb, mrdb_state *mrdb)
 }
 
 static int32_t
-check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
+check_method_breakpoint(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
 {
   struct RClass* c;
   mrb_sym sym;
@@ -545,7 +545,7 @@ check_method_breakpoint(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_
 }
 
 static void
-mrb_code_fetch_hook(mrb_state *mrb, mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
+mrb_code_fetch_hook(mrb_state *mrb, const mrb_irep *irep, const mrb_code *pc, mrb_value *regs)
 {
   const char *file;
   int32_t line;
diff --git a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
index 7c21de317..0c6505737 100644
--- a/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
+++ b/mrbgems/mruby-bin-debugger/tools/mrdb/mrdb.h
@@ -103,8 +103,8 @@ typedef struct mrb_debug_breakpoint {
 } mrb_debug_breakpoint;
 
 typedef struct mrb_debug_context {
-  struct mrb_irep *root_irep;
-  struct mrb_irep *irep;
+  const struct mrb_irep *root_irep;
+  const struct mrb_irep *irep;
   const mrb_code *pc;
   mrb_value *regs;
 
diff --git a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
index 51ba3fd78..8fa4fa822 100644
--- a/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
+++ b/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c
@@ -104,13 +104,13 @@ p(mrb_state *mrb, mrb_value obj, int prompt)
   mrb_value val;
   char* msg;
 
-  val = mrb_funcall(mrb, obj, "inspect", 0);
+  val = mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0);
   if (prompt) {
     if (!mrb->exc) {
       fputs(" => ", stdout);
     }
     else {
-      val = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0);
+      val = mrb_funcall_id(mrb, mrb_obj_value(mrb->exc), MRB_SYM(inspect), 0);
     }
   }
   if (!mrb_string_p(val)) {
@@ -525,10 +525,7 @@ main(int argc, char **argv)
 
   while (TRUE) {
     char *utf8;
-    struct mrb_jmpbuf c_jmp;
 
-    MRB_TRY(&c_jmp);
-    mrb->jmp = &c_jmp;
     if (args.rfp) {
       if (fgets(last_code_line, sizeof(last_code_line)-1, args.rfp) != NULL)
         goto done;
@@ -672,7 +669,7 @@ main(int argc, char **argv)
         }
         else {
           /* no */
-          if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect"))){
+          if (!mrb_respond_to(mrb, result, MRB_SYM(inspect))){
             result = mrb_any_to_s(mrb, result);
           }
           p(mrb, result, 1);
@@ -687,11 +684,6 @@ main(int argc, char **argv)
     }
     mrb_parser_free(parser);
     cxt->lineno++;
-    MRB_CATCH(&c_jmp) {
-      p(mrb, mrb_obj_value(mrb->exc), 0);
-      mrb->exc = 0;
-    }
-    MRB_END_EXC(&c_jmp);
   }
 
 #ifdef ENABLE_READLINE
diff --git a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c
index 4d984e773..acad28bd8 100644
--- a/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c
+++ b/mrbgems/mruby-bin-mrbc/tools/mrbc/mrbc.c
@@ -20,6 +20,7 @@ struct mrbc_args {
   const char *prog;
   const char *outfile;
   const char *initname;
+  mrb_bool dump_struct  : 1;
   mrb_bool check_syntax : 1;
   mrb_bool verbose      : 1;
   mrb_bool remove_lv    : 1;
@@ -32,10 +33,11 @@ usage(const char *name)
   static const char *const usage_msg[] = {
   "switches:",
   "-c           check syntax only",
-  "-o<outfile>  place the output into <outfile>",
+  "-o<outfile>  place the output into <outfile>; required for multi-files",
   "-v           print version number, then turn on verbose mode",
   "-g           produce debugging information",
   "-B<symbol>   binary <symbol> output in C language format",
+  "-S           dump C struct (requires -B)",
   "--remove-lv  remove local variables",
   "--verbose    run at verbose mode",
   "--version    print the version",
@@ -44,7 +46,7 @@ usage(const char *name)
   };
   const char *const *p = usage_msg;
 
-  printf("Usage: %s [switches] programfile\n", name);
+  printf("Usage: %s [switches] programfile...\n", name);
   while (*p)
     printf("  %s\n", *p++);
 }
@@ -105,6 +107,9 @@ parse_args(mrb_state *mrb, int argc, char **argv, struct mrbc_args *args)
           args->outfile = get_outfilename(mrb, argv[i] + 2, "");
         }
         break;
+      case 'S':
+        args->dump_struct = TRUE;
+        break;
       case 'B':
         if (argv[i][2] == '\0' && argv[i+1]) {
           i++;
@@ -238,13 +243,18 @@ static int
 dump_file(mrb_state *mrb, FILE *wfp, const char *outfile, struct RProc *proc, struct mrbc_args *args)
 {
   int n = MRB_DUMP_OK;
-  mrb_irep *irep = proc->body.irep;
+  const mrb_irep *irep = proc->body.irep;
 
   if (args->remove_lv) {
-    mrb_irep_remove_lv(mrb, irep);
+    mrb_irep_remove_lv(mrb, (mrb_irep*)irep);
   }
   if (args->initname) {
-    n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname);
+    if (args->dump_struct) {
+      n = mrb_dump_irep_cstruct(mrb, irep, args->flags, wfp, args->initname);
+    }
+    else {
+      n = mrb_dump_irep_cfunc(mrb, irep, args->flags, wfp, args->initname);
+    }
     if (n == MRB_DUMP_INVALID_ARGUMENT) {
       fprintf(stderr, "%s: invalid C language symbol name\n", args->initname);
     }
diff --git a/mrbgems/mruby-catch/mrbgem.rake b/mrbgems/mruby-catch/mrbgem.rake
new file mode 100644
index 000000000..c714d443d
--- /dev/null
+++ b/mrbgems/mruby-catch/mrbgem.rake
@@ -0,0 +1,5 @@
+MRuby::Gem::Specification.new('mruby-catch') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+  spec.summary = 'Catch / Throw non-local Jump'
+end
diff --git a/mrbgems/mruby-catch/mrblib/catch.rb b/mrbgems/mruby-catch/mrblib/catch.rb
new file mode 100644
index 000000000..89eedf66a
--- /dev/null
+++ b/mrbgems/mruby-catch/mrblib/catch.rb
@@ -0,0 +1,27 @@
+class ThrowCatchJump < Exception
+  def initialize(tag, val)
+    @tag = tag
+    @val = val
+    super("uncaught throw :#{tag}")
+  end
+  def _tag
+    @tag
+  end
+  def _val
+    @val
+  end
+end
+
+module Kernel
+  def catch(tag, &block)
+    block.call(tag)
+  rescue ThrowCatchJump => e
+    unless e._tag == tag
+      raise e
+    end
+    return e._val
+  end
+  def throw(tag, val=nil)
+    raise ThrowCatchJump.new(tag, val)
+  end
+end
diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c
index c64ffc473..eb37cd701 100644
--- a/mrbgems/mruby-compiler/core/codegen.c
+++ b/mrbgems/mruby-compiler/core/codegen.c
@@ -5,13 +5,13 @@
 */
 
 #include <ctype.h>
-#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
 #include <mruby.h>
 #include <mruby/compile.h>
 #include <mruby/proc.h>
+#include <mruby/dump.h>
 #include <mruby/numeric.h>
 #include <mruby/string.h>
 #include <mruby/debug.h>
@@ -40,7 +40,6 @@ enum looptype {
 struct loopinfo {
   enum looptype type;
   int pc0, pc1, pc2, pc3, acc;
-  int ensure_level;
   struct loopinfo *prev;
 };
 
@@ -61,7 +60,6 @@ typedef struct scope {
   mrb_bool mscope:1;
 
   struct loopinfo *loop;
-  int ensure_level;
   mrb_sym filename_sym;
   uint16_t lineno;
 
@@ -70,6 +68,10 @@ typedef struct scope {
   uint32_t icapa;
 
   mrb_irep *irep;
+  mrb_pool_value *pool;
+  mrb_sym *syms;
+  mrb_irep **reps;
+  struct mrb_irep_catch_handler *catch_table;
   uint32_t pcapa, scapa, rcapa;
 
   uint16_t nlocals;
@@ -89,6 +91,15 @@ static struct loopinfo *loop_push(codegen_scope *s, enum looptype t);
 static void loop_break(codegen_scope *s, node *tree);
 static void loop_pop(codegen_scope *s, int val);
 
+/*
+ * The search for catch handlers starts at the end of the table in mrb_vm_run().
+ * Therefore, the next handler to be added must meet one of the following conditions.
+ * - Larger start position
+ * - Same start position but smaller end position
+ */
+static int catch_handler_new(codegen_scope *s);
+static void catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target);
+
 static void gen_assignment(codegen_scope *s, node *tree, int sp, int val);
 static void gen_vmassignment(codegen_scope *s, node *tree, int rhs, int val);
 
@@ -98,10 +109,22 @@ static void raise_error(codegen_scope *s, const char *msg);
 static void
 codegen_error(codegen_scope *s, const char *message)
 {
+  int i;
+
   if (!s) return;
   while (s->prev) {
     codegen_scope *tmp = s->prev;
     mrb_free(s->mrb, s->iseq);
+    mrb_free(s->mrb, s->pool);
+    mrb_free(s->mrb, s->syms);
+    if (s->reps) {
+      /* copied from mrb_irep_free() in state.c */
+      for (i=0; i<s->irep->rlen; i++) {
+        if (s->reps[i])
+          mrb_irep_decref(s->mrb, (mrb_irep*)s->reps[i]);
+      }
+      mrb_free(s->mrb, s->reps);
+    }
     mrb_free(s->mrb, s->lines);
     mrb_pool_close(s->mpool);
     s = tmp;
@@ -203,9 +226,7 @@ genop_1(codegen_scope *s, mrb_code i, uint16_t a)
 {
   s->lastpc = s->pc;
   if (a > 0xff) {
-    gen_B(s, OP_EXT1);
-    gen_B(s, i);
-    gen_S(s, a);
+    codegen_error(s, "too big operand");
   }
   else {
     gen_B(s, i);
@@ -217,23 +238,8 @@ static void
 genop_2(codegen_scope *s, mrb_code i, uint16_t a, uint16_t b)
 {
   s->lastpc = s->pc;
-  if (a > 0xff && b > 0xff) {
-    gen_B(s, OP_EXT3);
-    gen_B(s, i);
-    gen_S(s, a);
-    gen_S(s, b);
-  }
-  else if (b > 0xff) {
-    gen_B(s, OP_EXT2);
-    gen_B(s, i);
-    gen_B(s, (uint8_t)a);
-    gen_S(s, b);
-  }
-  else if (a > 0xff) {
-    gen_B(s, OP_EXT1);
-    gen_B(s, i);
-    gen_S(s, a);
-    gen_B(s, (uint8_t)b);
+  if (a > 0xff || b > 0xff) {
+    codegen_error(s, "too big operand");
   }
   else {
     gen_B(s, i);
@@ -295,32 +301,6 @@ mrb_decode_insn(const mrb_code *pc)
 #define OPCODE(i,x) case OP_ ## i: FETCH_ ## x (); break;
 #include "mruby/ops.h"
 #undef OPCODE
-  }
-  switch (insn) {
-  case OP_EXT1:
-    insn = READ_B();
-    switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
-    }
-    break;
-  case OP_EXT2:
-    insn = READ_B();
-    switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
-    }
-    break;
-  case OP_EXT3:
-    insn = READ_B();
-    switch (insn) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); break;
-#include "mruby/ops.h"
-#undef OPCODE
-    }
-    break;
   default:
     break;
   }
@@ -377,11 +357,8 @@ genjmp2(codegen_scope *s, mrb_code i, uint16_t a, int pc, int val)
 
   s->lastpc = s->pc;
   if (a > 0xff) {
-    gen_B(s, OP_EXT1);
-    gen_B(s, i);
-    gen_S(s, a);
-    pos = s->pc;
-    gen_S(s, pc);
+    codegen_error(s, "too big operand");
+    pos = 0;
   }
   else {
     gen_B(s, i);
@@ -539,37 +516,46 @@ static inline int
 new_lit(codegen_scope *s, mrb_value val)
 {
   int i;
-  mrb_value *pv;
+  mrb_pool_value *pv;
 
   switch (mrb_type(val)) {
   case MRB_TT_STRING:
     for (i=0; i<s->irep->plen; i++) {
       mrb_int len;
-      pv = &s->irep->pool[i];
-
-      if (!mrb_string_p(*pv)) continue;
-      if ((len = RSTRING_LEN(*pv)) != RSTRING_LEN(val)) continue;
-      if (memcmp(RSTRING_PTR(*pv), RSTRING_PTR(val), len) == 0)
+      pv = &s->pool[i];
+      if (pv->tt & IREP_TT_NFLAG) continue;
+      len = pv->tt>>2;
+      if (RSTRING_LEN(val) != len) continue;
+      if (memcmp(pv->u.str, RSTRING_PTR(val), len) == 0)
         return i;
     }
     break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
     for (i=0; i<s->irep->plen; i++) {
       mrb_float f1, f2;
-      pv = &s->irep->pool[i];
-      if (!mrb_float_p(*pv)) continue;
-      f1 = mrb_float(*pv);
+      pv = &s->pool[i];
+      if (pv->tt != IREP_TT_FLOAT) continue;
+      pv = &s->pool[i];
+      f1 = pv->u.f;
       f2 = mrb_float(val);
       if (f1 == f2 && !signbit(f1) == !signbit(f2)) return i;
     }
     break;
 #endif
-  case MRB_TT_FIXNUM:
+  case MRB_TT_INTEGER:
     for (i=0; i<s->irep->plen; i++) {
-      pv = &s->irep->pool[i];
-      if (!mrb_fixnum_p(*pv)) continue;
-      if (mrb_fixnum(*pv) == mrb_fixnum(val)) return i;
+      mrb_int v = mrb_integer(val);
+      pv = &s->pool[i];
+      if (pv->tt == IREP_TT_INT32) {
+        if (v == pv->u.i32) return i;
+      }
+#ifdef MRB_64BIT
+      else if (pv->tt == IREP_TT_INT64) {
+        if (v == pv->u.i64) return i;
+      }
+      continue;
+#endif
     }
     break;
   default:
@@ -579,26 +565,43 @@ new_lit(codegen_scope *s, mrb_value val)
 
   if (s->irep->plen == s->pcapa) {
     s->pcapa *= 2;
-    s->irep->pool = (mrb_value *)codegen_realloc(s, s->irep->pool, sizeof(mrb_value)*s->pcapa);
+    s->pool = (mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*s->pcapa);
   }
 
-  pv = &s->irep->pool[s->irep->plen];
+  pv = &s->pool[s->irep->plen];
   i = s->irep->plen++;
 
   switch (mrb_type(val)) {
   case MRB_TT_STRING:
-    *pv = mrb_str_pool(s->mrb, RSTRING_PTR(val), RSTRING_LEN(val), RSTR_NOFREE_P(RSTRING(val)));
+    if (RSTR_NOFREE_P(RSTRING(val))) {
+      pv->tt = (uint32_t)(RSTRING_LEN(val)<<2) | IREP_TT_SSTR;
+      pv->u.str = RSTRING_PTR(val);
+    }
+    else {
+      char *p;
+      mrb_int len = RSTRING_LEN(val);
+      pv->tt = (uint32_t)(len<<2) | IREP_TT_STR;
+      p = (char*)codegen_realloc(s, NULL, len+1);
+      memcpy(p, RSTRING_PTR(val), len);
+      p[len] = '\0';
+      pv->u.str = p;
+    }
     break;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
-#ifdef MRB_WORD_BOXING
-    *pv = mrb_float_pool(s->mrb, mrb_float(val));
+    pv->tt = IREP_TT_FLOAT;
+    pv->u.f = mrb_float(val);
     break;
 #endif
+  case MRB_TT_INTEGER:
+#ifdef MRB_INT64
+    pv->tt = IREP_TT_INT64;
+    pv->u.i64 = mrb_integer(val);
+#else
+    pv->tt = IREP_TT_INT32;
+    pv->u.i32 = mrb_integer(val);
 #endif
-  case MRB_TT_FIXNUM:
-    *pv = val;
     break;
 
   default:
@@ -620,13 +623,13 @@ new_sym(codegen_scope *s, mrb_sym sym)
 
   len = s->irep->slen;
   for (i=0; i<len; i++) {
-    if (s->irep->syms[i] == sym) return i;
+    if (s->syms[i] == sym) return i;
   }
   if (s->irep->slen >= s->scapa) {
     s->scapa *= 2;
-    s->irep->syms = (mrb_sym*)codegen_realloc(s, s->irep->syms, sizeof(mrb_sym)*s->scapa);
+    s->syms = (mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*s->scapa);
   }
-  s->irep->syms[s->irep->slen] = sym;
+  s->syms[s->irep->slen] = sym;
   return s->irep->slen++;
 }
 
@@ -665,7 +668,7 @@ lv_idx(codegen_scope *s, mrb_sym id)
 static int
 search_upvar(codegen_scope *s, mrb_sym id, int *idx)
 {
-  struct RProc *u;
+  const struct RProc *u;
   int lv = 0;
   codegen_scope *up = s->prev;
 
@@ -681,12 +684,14 @@ search_upvar(codegen_scope *s, mrb_sym id, int *idx)
   if (lv < 1) lv = 1;
   u = s->parser->upper;
   while (u && !MRB_PROC_CFUNC_P(u)) {
-    struct mrb_irep *ir = u->body.irep;
+    const struct mrb_irep *ir = u->body.irep;
     uint_fast16_t n = ir->nlocals;
-    const struct mrb_locals *v = ir->lv;
-    for (; n > 1; n --, v ++) {
-      if (v->name == id) {
-        *idx = v->r;
+    int i;
+
+    const mrb_sym *v = ir->lv;
+    for (i=1; n > 1; n--, v++, i++) {
+      if (*v == id) {
+        *idx = i;
         return lv - 1;
       }
     }
@@ -737,7 +742,7 @@ for_body(codegen_scope *s, node *tree)
   genop_2(s, OP_BLOCK, cursp(), s->irep->rlen-1);
   push();pop(); /* space for a block */
   pop();
-  idx = new_sym(s, mrb_intern_lit(s->mrb, "each"));
+  idx = new_sym(s, MRB_SYM(each));
   genop_3(s, OP_SENDB, cursp(), idx, 0);
 }
 
@@ -1325,7 +1330,7 @@ raise_error(codegen_scope *s, const char *msg)
   genop_1(s, OP_ERR, idx);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static double
 readint_float(codegen_scope *s, const char *p, int base)
 {
@@ -1458,16 +1463,19 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       int noexc, exend, pos1, pos2, tmp;
       struct loopinfo *lp;
+      int catch_entry, begin, end;
 
       if (tree->car == NULL) goto exit;
       lp = loop_push(s, LOOP_BEGIN);
       lp->pc0 = new_label(s);
-      lp->pc1 = genjmp(s, OP_ONERR, 0);
+      catch_entry = catch_handler_new(s);
+      begin = s->pc;
       codegen(s, tree->car, VAL);
       pop();
       lp->type = LOOP_RESCUE;
+      end = s->pc;
       noexc = genjmp(s, OP_JMP, 0);
-      dispatch(s, lp->pc1);
+      catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc);
       tree = tree->cdr;
       exend = 0;
       pos1 = 0;
@@ -1489,14 +1497,14 @@ codegen(codegen_scope *s, node *tree, int val)
               gen_move(s, cursp(), exc, 0);
               push_n(2); pop_n(2); /* space for one arg and a block */
               pop();
-              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1);
+              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(__case_eqq)), 1);
             }
             else {
               if (n4) {
                 codegen(s, n4->car, VAL);
               }
               else {
-                genop_2(s, OP_GETCONST, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "StandardError")));
+                genop_2(s, OP_GETCONST, cursp(), new_sym(s, MRB_SYM(StandardError)));
                 push();
               }
               pop();
@@ -1526,13 +1534,12 @@ codegen(codegen_scope *s, node *tree, int val)
         }
         if (pos1) {
           dispatch(s, pos1);
-          genop_1(s, OP_RAISE, exc);
+          genop_1(s, OP_RAISEIF, exc);
         }
       }
       pop();
       tree = tree->cdr;
       dispatch(s, noexc);
-      genop_1(s, OP_POPERR, 1);
       if (tree->car) {
         codegen(s, tree->car, val);
       }
@@ -1548,14 +1555,22 @@ codegen(codegen_scope *s, node *tree, int val)
     if (!tree->cdr || !tree->cdr->cdr ||
         (nint(tree->cdr->cdr->car) == NODE_BEGIN &&
          tree->cdr->cdr->cdr)) {
+      int catch_entry, begin, end, target;
       int idx;
 
-      s->ensure_level++;
-      idx = scope_body(s, tree->cdr, NOVAL);
-      genop_1(s, OP_EPUSH, idx);
+      catch_entry = catch_handler_new(s);
+      begin = s->pc;
       codegen(s, tree->car, val);
-      s->ensure_level--;
-      genop_1(s, OP_EPOP, 1);
+      end = target = s->pc;
+      push();
+      idx = cursp();
+      genop_1(s, OP_EXCEPT, idx);
+      push();
+      codegen(s, tree->cdr->cdr, NOVAL);
+      pop();
+      genop_1(s, OP_RAISEIF, idx);
+      pop();
+      catch_handler_set(s, catch_entry, MRB_CATCH_ENSURE, begin, end, target);
     }
     else {                      /* empty ensure ignored */
       codegen(s, tree->car, val);
@@ -1603,7 +1618,7 @@ codegen(codegen_scope *s, node *tree, int val)
         {
           node *n = tree->car->cdr;
           mrb_sym mid = nsym(n->cdr->car);
-          mrb_sym mnil = mrb_intern_lit(s->mrb, "nil?");
+          mrb_sym mnil = MRB_QSYM(nil_p);
           if (mid == mnil && n->cdr->cdr->car == NULL) {
             nil_p = TRUE;
             codegen(s, n->car, VAL);
@@ -1739,10 +1754,10 @@ codegen(codegen_scope *s, node *tree, int val)
             gen_move(s, cursp(), head, 0);
             push(); push(); pop(); pop(); pop();
             if (nint(n->car->car) == NODE_SPLAT) {
-              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "__case_eqq")), 1);
+              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(__case_eqq)), 1);
             }
             else {
-              genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "===")), 1);
+              genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_QSYM(eqq)), 1);
             }
           }
           else {
@@ -2017,18 +2032,20 @@ codegen(codegen_scope *s, node *tree, int val)
       if ((len == 2 && name[0] == '|' && name[1] == '|') &&
           (nint(tree->car->car) == NODE_CONST ||
            nint(tree->car->car) == NODE_CVAR)) {
-        int onerr, noexc, exc;
+        int catch_entry, begin, end;
+        int noexc, exc;
         struct loopinfo *lp;
 
-        onerr = genjmp(s, OP_ONERR, 0);
         lp = loop_push(s, LOOP_BEGIN);
-        lp->pc1 = onerr;
+        lp->pc0 = new_label(s);
+        catch_entry = catch_handler_new(s);
+        begin = s->pc;
         exc = cursp();
         codegen(s, tree->car, VAL);
-        lp->type = LOOP_RESCUE;
-        genop_1(s, OP_POPERR, 1);
+        end = s->pc;
         noexc = genjmp(s, OP_JMP, 0);
-        dispatch(s, onerr);
+        lp->type = LOOP_RESCUE;
+        catch_handler_set(s, catch_entry, MRB_CATCH_RESCUE, begin, end, s->pc);
         genop_1(s, OP_EXCEPT, exc);
         genop_1(s, OP_LOADF, exc);
         dispatch(s, noexc);
@@ -2266,7 +2283,7 @@ codegen(codegen_scope *s, node *tree, int val)
       pop_n(n+1);
       genop_2S(s, OP_BLKPUSH, cursp(), (ainfo<<4)|(lv & 0xf));
       if (sendv) n = CALL_MAXARGS;
-      genop_3(s, OP_SEND, cursp(), new_sym(s, mrb_intern_lit(s->mrb, "call")), n);
+      genop_3(s, OP_SEND, cursp(), new_sym(s, MRB_SYM(call)), n);
       if (val) push();
     }
     break;
@@ -2281,11 +2298,8 @@ codegen(codegen_scope *s, node *tree, int val)
       raise_error(s, "unexpected next");
     }
     else if (s->loop->type == LOOP_NORMAL) {
-      if (s->ensure_level > s->loop->ensure_level) {
-        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
-      }
       codegen(s, tree, NOVAL);
-      genjmp(s, OP_JMP, s->loop->pc0);
+      genjmp(s, OP_JMPUW, s->loop->pc0);
     }
     else {
       if (tree) {
@@ -2305,10 +2319,7 @@ codegen(codegen_scope *s, node *tree, int val)
       raise_error(s, "unexpected redo");
     }
     else {
-      if (s->ensure_level > s->loop->ensure_level) {
-        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
-      }
-      genjmp(s, OP_JMP, s->loop->pc2);
+      genjmp(s, OP_JMPUW, s->loop->pc2);
     }
     if (val) push();
     break;
@@ -2316,32 +2327,16 @@ codegen(codegen_scope *s, node *tree, int val)
   case NODE_RETRY:
     {
       const char *msg = "unexpected retry";
+      const struct loopinfo *lp = s->loop;
 
-      if (!s->loop) {
+      while (lp && lp->type != LOOP_RESCUE) {
+        lp = lp->prev;
+      }
+      if (!lp) {
         raise_error(s, msg);
       }
       else {
-        struct loopinfo *lp = s->loop;
-        int n = 0;
-
-        while (lp && lp->type != LOOP_RESCUE) {
-          if (lp->type == LOOP_BEGIN) {
-            n++;
-          }
-          lp = lp->prev;
-        }
-        if (!lp) {
-          raise_error(s, msg);
-        }
-        else {
-          if (n > 0) {
-            genop_1(s, OP_POPERR, n);
-          }
-          if (s->ensure_level > lp->ensure_level) {
-            genop_1(s, OP_EPOP, s->ensure_level - lp->ensure_level);
-          }
-          genjmp(s, OP_JMP, lp->pc0);
-        }
+        genjmp(s, OP_JMPUW, lp->pc0);
       }
       if (val) push();
     }
@@ -2447,7 +2442,7 @@ codegen(codegen_scope *s, node *tree, int val)
       mrb_bool overflow;
 
       i = readint_mrb_int(s, p, base, FALSE, &overflow);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       if (overflow) {
         double f = readint_float(s, p, base);
         int off = new_lit(s, mrb_float_value(s->mrb, f));
@@ -2470,7 +2465,7 @@ codegen(codegen_scope *s, node *tree, int val)
           int off;
 
         lit_int:
-          off = new_lit(s, mrb_fixnum_value(i));
+          off = new_lit(s, mrb_int_value(s->mrb, i));
           genop_2(s, OP_LOADL, cursp(), off);
         }
       }
@@ -2478,7 +2473,7 @@ codegen(codegen_scope *s, node *tree, int val)
     }
     break;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case NODE_FLOAT:
     if (val) {
       char *p = (char*)tree;
@@ -2495,7 +2490,7 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       nt = nint(tree->car);
       switch (nt) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       case NODE_FLOAT:
         if (val) {
           char *p = (char*)tree->cdr;
@@ -2516,7 +2511,7 @@ codegen(codegen_scope *s, node *tree, int val)
           mrb_bool overflow;
 
           i = readint_mrb_int(s, p, base, TRUE, &overflow);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
           if (overflow) {
             double f = readint_float(s, p, base);
             int off = new_lit(s, mrb_float_value(s->mrb, -f));
@@ -2533,10 +2528,10 @@ codegen(codegen_scope *s, node *tree, int val)
               genop_2S(s, OP_LOADI16, cursp(), (uint16_t)i);
             }
             else {
-              int off = new_lit(s, mrb_fixnum_value(i));
+              int off = new_lit(s, mrb_int_value(s->mrb, i));
               genop_2(s, OP_LOADL, cursp(), off);
             }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
           }
 #endif
           push();
@@ -2545,7 +2540,7 @@ codegen(codegen_scope *s, node *tree, int val)
 
       default:
         if (val) {
-          int sym = new_sym(s, mrb_intern_lit(s->mrb, "-@"));
+          int sym = new_sym(s, MRB_QSYM(minus));
           codegen(s, tree, VAL);
           pop();
           genop_3(s, OP_SEND, cursp(), sym, 0);
@@ -2618,7 +2613,7 @@ codegen(codegen_scope *s, node *tree, int val)
     {
       node *n;
       int ai = mrb_gc_arena_save(s->mrb);
-      int sym = new_sym(s, mrb_intern_lit(s->mrb, "Kernel"));
+      int sym = new_sym(s, MRB_SYM(Kernel));
 
       genop_1(s, OP_LOADSELF, cursp());
       push();
@@ -2637,7 +2632,7 @@ codegen(codegen_scope *s, node *tree, int val)
       }
       push();                   /* for block */
       pop_n(3);
-      sym = new_sym(s, mrb_intern_lit(s->mrb, "`"));
+      sym = new_sym(s, MRB_QSYM(tick)); /* ` */
       genop_3(s, OP_SEND, cursp(), sym, 1);
       if (val) push();
       mrb_gc_arena_restore(s->mrb, ai);
@@ -2657,7 +2652,7 @@ codegen(codegen_scope *s, node *tree, int val)
       genop_2(s, OP_STRING, cursp(), off);
       push(); push();
       pop_n(3);
-      sym = new_sym(s, mrb_intern_lit(s->mrb, "`"));
+      sym = new_sym(s, MRB_QSYM(tick)); /* ` */
       genop_3(s, OP_SEND, cursp(), sym, 1);
       if (val) push();
       mrb_gc_arena_restore(s->mrb, ai);
@@ -2698,7 +2693,7 @@ codegen(codegen_scope *s, node *tree, int val)
       }
       push(); /* space for a block */
       pop_n(argc+2);
-      sym = new_sym(s, mrb_intern_lit(s->mrb, "compile"));
+      sym = new_sym(s, MRB_SYM(compile));
       genop_3(s, OP_SEND, cursp(), sym, argc);
       mrb_gc_arena_restore(s->mrb, ai);
       push();
@@ -2752,7 +2747,7 @@ codegen(codegen_scope *s, node *tree, int val)
       }
       push(); /* space for a block */
       pop_n(argc+2);
-      sym = new_sym(s, mrb_intern_lit(s->mrb, "compile"));
+      sym = new_sym(s, MRB_SYM(compile));
       genop_3(s, OP_SEND, cursp(), sym, argc);
       mrb_gc_arena_restore(s->mrb, ai);
       push();
@@ -2993,91 +2988,86 @@ scope_add_irep(codegen_scope *s, mrb_irep *irep)
   }
   if (s->irep->rlen == s->rcapa) {
     s->rcapa *= 2;
-    s->irep->reps = (mrb_irep**)codegen_realloc(s, s->irep->reps, sizeof(mrb_irep*)*s->rcapa);
+    s->reps = (mrb_irep**)codegen_realloc(s, s->reps, sizeof(mrb_irep*)*s->rcapa);
   }
-  s->irep->reps[s->irep->rlen] = irep;
+  s->reps[s->irep->rlen] = irep;
   s->irep->rlen++;
 }
 
 static codegen_scope*
-scope_new(mrb_state *mrb, codegen_scope *prev, node *lv)
+scope_new(mrb_state *mrb, codegen_scope *prev, node *nlv)
 {
   static const codegen_scope codegen_scope_zero = { 0 };
   mrb_pool *pool = mrb_pool_open(mrb);
-  codegen_scope *p = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
+  codegen_scope *s = (codegen_scope *)mrb_pool_alloc(pool, sizeof(codegen_scope));
 
-  if (!p) {
+  if (!s) {
     if (prev)
       codegen_error(prev, "unexpected scope");
     return NULL;
   }
-  *p = codegen_scope_zero;
-  p->mrb = mrb;
-  p->mpool = pool;
-  if (!prev) return p;
-  p->prev = prev;
-  p->ainfo = -1;
-  p->mscope = 0;
-
-  p->irep = mrb_add_irep(mrb);
-  scope_add_irep(prev, p->irep);
-
-  p->rcapa = 8;
-  p->irep->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*p->rcapa);
-
-  p->icapa = 1024;
-  p->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*p->icapa);
-  p->irep->iseq = NULL;
-
-  p->pcapa = 32;
-  p->irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value)*p->pcapa);
-  p->irep->plen = 0;
-
-  p->scapa = 256;
-  p->irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*p->scapa);
-  p->irep->slen = 0;
-
-  p->lv = lv;
-  p->sp += node_len(lv)+1;        /* add self */
-  p->nlocals = p->sp;
-  if (lv) {
-    node *n = lv;
+  *s = codegen_scope_zero;
+  s->mrb = mrb;
+  s->mpool = pool;
+  if (!prev) return s;
+  s->prev = prev;
+  s->ainfo = -1;
+  s->mscope = 0;
+
+  s->irep = mrb_add_irep(mrb);
+  scope_add_irep(prev, s->irep);
+
+  s->rcapa = 8;
+  s->reps = (mrb_irep**)mrb_malloc(mrb, sizeof(mrb_irep*)*s->rcapa);
+
+  s->icapa = 1024;
+  s->iseq = (mrb_code*)mrb_malloc(mrb, sizeof(mrb_code)*s->icapa);
+  s->irep->iseq = NULL;
+
+  s->pcapa = 32;
+  s->pool = (mrb_pool_value*)mrb_malloc(mrb, sizeof(mrb_pool_value)*s->pcapa);
+  s->irep->plen = 0;
+
+  s->scapa = 256;
+  s->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*s->scapa);
+  s->irep->slen = 0;
+
+  s->lv = nlv;
+  s->sp += node_len(nlv)+1;        /* add self */
+  s->nlocals = s->sp;
+  if (nlv) {
+    mrb_sym *lv;
+    node *n = nlv;
     size_t i = 0;
 
-    p->irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (p->nlocals - 1));
-    for (i=0, n=lv; n; i++,n=n->cdr) {
-      p->irep->lv[i].name = lv_name(n);
-      if (lv_name(n)) {
-        p->irep->lv[i].r = lv_idx(p, lv_name(n));
-      }
-      else {
-        p->irep->lv[i].r = 0;
-      }
+    s->irep->lv = lv = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*(s->nlocals-1));
+    for (i=0, n=nlv; n; i++,n=n->cdr) {
+      lv[i] = lv_name(n);
     }
-    mrb_assert(i + 1 == p->nlocals);
+    mrb_assert(i + 1 == s->nlocals);
   }
-  p->ai = mrb_gc_arena_save(mrb);
+  s->ai = mrb_gc_arena_save(mrb);
 
-  p->filename_sym = prev->filename_sym;
-  if (p->filename_sym) {
-    p->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*p->icapa);
+  s->filename_sym = prev->filename_sym;
+  if (s->filename_sym) {
+    s->lines = (uint16_t*)mrb_malloc(mrb, sizeof(short)*s->icapa);
   }
-  p->lineno = prev->lineno;
+  s->lineno = prev->lineno;
 
   /* debug setting */
-  p->debug_start_pos = 0;
-  if (p->filename_sym) {
-    mrb_debug_info_alloc(mrb, p->irep);
+  s->debug_start_pos = 0;
+  if (s->filename_sym) {
+    mrb_debug_info_alloc(mrb, s->irep);
   }
   else {
-    p->irep->debug_info = NULL;
+    s->irep->debug_info = NULL;
   }
-  p->parser = prev->parser;
-  p->filename_index = prev->filename_index;
+  s->parser = prev->parser;
+  s->filename_index = prev->filename_index;
 
-  p->rlev = prev->rlev+1;
+  s->rlev = prev->rlev+1;
 
-  return p;
+  return s;
 }
 
 static void
@@ -3091,12 +3081,21 @@ scope_finish(codegen_scope *s)
   }
   irep->flags = 0;
   if (s->iseq) {
-    irep->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc);
+    size_t catchsize = sizeof(struct mrb_irep_catch_handler) * irep->clen;
+    irep->iseq = (const mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->pc + catchsize);
     irep->ilen = s->pc;
+    if (irep->clen > 0) {
+      memcpy((void *)(irep->iseq + irep->ilen), s->catch_table, catchsize);
+    }
+  }
+  else {
+    irep->clen = 0;
   }
-  irep->pool = (mrb_value*)codegen_realloc(s, irep->pool, sizeof(mrb_value)*irep->plen);
-  irep->syms = (mrb_sym*)codegen_realloc(s, irep->syms, sizeof(mrb_sym)*irep->slen);
-  irep->reps = (mrb_irep**)codegen_realloc(s, irep->reps, sizeof(mrb_irep*)*irep->rlen);
+  mrb_free(s->mrb, s->catch_table);
+  s->catch_table = NULL;
+  irep->pool = (const mrb_pool_value*)codegen_realloc(s, s->pool, sizeof(mrb_pool_value)*irep->plen);
+  irep->syms = (const mrb_sym*)codegen_realloc(s, s->syms, sizeof(mrb_sym)*irep->slen);
+  irep->reps = (const mrb_irep**)codegen_realloc(s, s->reps, sizeof(mrb_irep*)*irep->rlen);
   if (s->filename_sym) {
     mrb_sym fname = mrb_parser_get_filename(s->parser, s->filename_index);
     const char *filename = mrb_sym_name_len(s->mrb, fname, NULL);
@@ -3121,7 +3120,6 @@ loop_push(codegen_scope *s, enum looptype t)
   p->type = t;
   p->pc0 = p->pc1 = p->pc2 = p->pc3 = 0;
   p->prev = s->loop;
-  p->ensure_level = s->ensure_level;
   p->acc = cursp();
   s->loop = p;
 
@@ -3137,7 +3135,6 @@ loop_break(codegen_scope *s, node *tree)
   }
   else {
     struct loopinfo *loop;
-    int n = 0;
 
     if (tree) {
       gen_retval(s, tree);
@@ -3146,7 +3143,6 @@ loop_break(codegen_scope *s, node *tree)
     loop = s->loop;
     while (loop) {
       if (loop->type == LOOP_BEGIN) {
-        n++;
         loop = loop->prev;
       }
       else if (loop->type == LOOP_RESCUE) {
@@ -3160,20 +3156,14 @@ loop_break(codegen_scope *s, node *tree)
       raise_error(s, "unexpected break");
       return;
     }
-    if (n > 0) {
-      genop_1(s, OP_POPERR, n);
-    }
 
     if (loop->type == LOOP_NORMAL) {
       int tmp;
 
-      if (s->ensure_level > s->loop->ensure_level) {
-        genop_1(s, OP_EPOP, s->ensure_level - s->loop->ensure_level);
-      }
       if (tree) {
         gen_move(s, loop->acc, cursp(), 0);
       }
-      tmp = genjmp(s, OP_JMP, loop->pc3);
+      tmp = genjmp(s, OP_JMPUW, loop->pc3);
       loop->pc3 = tmp;
     }
     else {
@@ -3196,6 +3186,31 @@ loop_pop(codegen_scope *s, int val)
   if (val) push();
 }
 
+static int
+catch_handler_new(codegen_scope *s)
+{
+  size_t newsize = sizeof(struct mrb_irep_catch_handler) * (s->irep->clen + 1);
+  s->catch_table = (struct mrb_irep_catch_handler *)codegen_realloc(s, (void *)s->catch_table, newsize);
+  return s->irep->clen ++;
+}
+
+static void
+catch_handler_set(codegen_scope *s, int ent, enum mrb_catch_type type, uint32_t begin, uint32_t end, uint32_t target)
+{
+  struct mrb_irep_catch_handler *e;
+
+  mrb_assert(ent >= 0 && ent < s->irep->clen);
+  mrb_assert(begin < MAXARG_S);
+  mrb_assert(end < MAXARG_S);
+  mrb_assert(target < MAXARG_S);
+
+  e = &s->catch_table[ent];
+  uint8_to_bin(type, &e->type);
+  uint16_to_bin(begin, e->begin);
+  uint16_to_bin(end, e->end);
+  uint16_to_bin(target, e->target);
+}
+
 static struct RProc*
 generate_code(mrb_state *mrb, parser_state *p, int val)
 {
@@ -3242,13 +3257,14 @@ mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep)
 {
   int i;
 
+  if (irep->flags & MRB_IREP_NO_FREE) return;
   if (irep->lv) {
-    mrb_free(mrb, irep->lv);
+    mrb_free(mrb, (void*)irep->lv);
     irep->lv = NULL;
   }
-
+  if (!irep->reps) return;
   for (i = 0; i < irep->rlen; ++i) {
-    mrb_irep_remove_lv(mrb, irep->reps[i]);
+    mrb_irep_remove_lv(mrb, (mrb_irep*)irep->reps[i]);
   }
 }
 
@@ -3272,35 +3288,3 @@ uint8_t mrb_insn_size[] = {
 #undef SB
 #undef BBB
 };
-/* EXT1 instruction sizes */
-uint8_t mrb_insn_size1[] = {
-#define B 3
-#define BB 4
-#define BBB 5
-#define BS 5
-#define SB 5
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-#undef OPCODE
-#undef B
-};
-/* EXT2 instruction sizes */
-uint8_t mrb_insn_size2[] = {
-#define B 2
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-#undef OPCODE
-#undef BB
-#undef BBB
-#undef BS
-#undef SB
-};
-/* EXT3 instruction sizes */
-#define BB 5
-#define BBB 6
-#define BS 4
-#define SB 5
-uint8_t mrb_insn_size3[] = {
-#define OPCODE(_,x) x,
-#include "mruby/ops.h"
-};
diff --git a/mrbgems/mruby-compiler/core/parse.y b/mrbgems/mruby-compiler/core/parse.y
index 9de45a536..3cd74971f 100644
--- a/mrbgems/mruby-compiler/core/parse.y
+++ b/mrbgems/mruby-compiler/core/parse.y
@@ -265,7 +265,7 @@ local_unnest(parser_state *p)
 static mrb_bool
 local_var_p(parser_state *p, mrb_sym sym)
 {
-  struct RProc *u;
+  const struct RProc *u;
   node *l = p->locals;
 
   while (l) {
@@ -279,11 +279,13 @@ local_var_p(parser_state *p, mrb_sym sym)
 
   u = p->upper;
   while (u && !MRB_PROC_CFUNC_P(u)) {
-    struct mrb_irep *ir = u->body.irep;
-    uint_fast16_t n = ir->nlocals;
-    const struct mrb_locals *v = ir->lv;
-    for (; n > 1; n --, v ++) {
-      if (v->name == sym) return TRUE;
+    const struct mrb_irep *ir = u->body.irep;
+    const mrb_sym *v = ir->lv;
+    int i;
+
+    if (!v) break;
+    for (i=0; i < ir->nlocals; i++) {
+      if (v[i] == sym) return TRUE;
     }
     if (MRB_PROC_SCOPE_P(u)) break;
     u = u->upper;
@@ -311,14 +313,14 @@ static void
 local_add_blk(parser_state *p, mrb_sym blk)
 {
   /* allocate register for block */
-  local_add_f(p, blk ? blk : mrb_intern_lit(p->mrb, "&"));
+  local_add_f(p, blk ? blk : MRB_QSYM(and));
 }
 
 static void
 local_add_kw(parser_state *p, mrb_sym kwd)
 {
   /* allocate register for keywords hash */
-  local_add_f(p, kwd ? kwd : mrb_intern_lit(p->mrb, "**"));
+  local_add_f(p, kwd ? kwd : MRB_QSYM(pow));
 }
 
 static node*
@@ -730,7 +732,19 @@ new_module(parser_state *p, node *m, node *b)
 static node*
 new_def(parser_state *p, mrb_sym m, node *a, node *b)
 {
-  return list5((node*)NODE_DEF, nsym(m), locals_node(p), a, b);
+  return list5((node*)NODE_DEF, nsym(m), 0, a, b);
+}
+
+static void
+defn_setup(parser_state *p, node *d, node *a, node *b)
+{
+  node *n = d->cdr->cdr;
+
+  n->car = locals_node(p);
+  p->cmdarg_stack = intn(n->cdr->car);
+  n->cdr->car = a;
+  local_resume(p, n->cdr->cdr->car);
+  n->cdr->cdr->car = b;
 }
 
 /* (:sdef obj m lv (arg . body)) */
@@ -738,7 +752,19 @@ static node*
 new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b)
 {
   void_expr_error(p, o);
-  return list6((node*)NODE_SDEF, o, nsym(m), locals_node(p), a, b);
+  return list6((node*)NODE_SDEF, o, nsym(m), 0, a, b);
+}
+
+static void
+defs_setup(parser_state *p, node *d, node *a, node *b)
+{
+  node *n = d->cdr->cdr->cdr;
+
+  n->car = locals_node(p);
+  p->cmdarg_stack = intn(n->cdr->car);
+  n->cdr->car = a;
+  local_resume(p, n->cdr->cdr->car);
+  n->cdr->cdr->car = b;
 }
 
 /* (:arg . sym) */
@@ -932,13 +958,13 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
 static node*
 new_imaginary(parser_state *p, node *imaginary)
 {
-  return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Complex"), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
+  return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Complex), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
 }
 
 static node*
 new_rational(parser_state *p, node *rational)
 {
-  return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Rational"), list1(list1(rational)), 1);
+  return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Rational), list1(list1(rational)), 1);
 }
 
 /* (:int . i) */
@@ -955,7 +981,7 @@ new_int(parser_state *p, const char *s, int base, int suffix)
   return result;
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /* (:float . i) */
 static node*
 new_float(parser_state *p, const char *s, int suffix)
@@ -1415,8 +1441,8 @@ heredoc_end(parser_state *p)
 %token <num> tNUMPARAM
 
 %type <nd> singleton string string_fragment string_rep string_interp xstring regexp
-%type <nd> literal numeric cpath symbol
-%type <nd> top_compstmt top_stmts top_stmt
+%type <nd> literal numeric cpath symbol defn_head defs_head
+%type <nd> top_compstmt top_stmts top_stmt rassign
 %type <nd> bodystmt compstmt stmts stmt expr arg primary command command_call method_call
 %type <nd> expr_value arg_rhs primary_value
 %type <nd> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure
@@ -1425,7 +1451,7 @@ heredoc_end(parser_state *p)
 %type <nd> command_args aref_args opt_block_arg block_arg var_ref var_lhs
 %type <nd> command_asgn command_rhs mrhs superclass block_call block_command
 %type <nd> f_block_optarg f_block_opt
-%type <nd> f_arglist f_args f_arg f_arg_item f_optarg f_margs
+%type <nd> f_arglist_paren f_arglist f_args f_arg f_arg_item f_optarg f_margs
 %type <nd> assoc_list assocs assoc undef_list backref for_var
 %type <nd> block_param opt_block_param block_param_def f_opt
 %type <nd> bv_decls opt_bv_decl bvar f_larglist lambda_body
@@ -1658,9 +1684,30 @@ stmt            : keyword_alias fsym {p->lstate = EXPR_FNAME;} fsym
                     {
                       $$ = new_masgn(p, $1, new_array(p, $3));
                     }
+                | rassign
                 | expr
                 ;
 
+rassign         : arg tASSOC lhs
+                    {
+                      void_expr_error(p, $1);
+                      $$ = new_asgn(p, $3, $1);
+                    }
+                | arg tASSOC mlhs
+                    {
+                      void_expr_error(p, $1);
+                      $$ = new_masgn(p, $3, $1);
+                    }
+                | rassign tASSOC lhs
+                    {
+                      $$ = new_asgn(p, $3, $1);
+                    }
+                | rassign tASSOC mlhs
+                    {
+                      $$ = new_masgn(p, $3, $1);
+                    }
+                ;
+
 command_asgn    : lhs '=' command_rhs
                     {
                       $$ = new_asgn(p, $1, $3);
@@ -1671,7 +1718,7 @@ command_asgn    : lhs '=' command_rhs
                     }
                 | primary_value '[' opt_call_args ']' tOP_ASGN command_rhs
                     {
-                      $$ = new_op_asgn(p, new_call(p, $1, intern_lit("[]"), $3, '.'), $5, $6);
+                      $$ = new_op_asgn(p, new_call(p, $1, MRB_QSYM(aref), $3, '.'), $5, $6);
                     }
                 | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
                     {
@@ -1726,6 +1773,31 @@ expr            : command_call
                 | arg
                 ;
 
+
+defn_head       : keyword_def fname
+                    {
+                      $$ = new_def(p, $2, nint(p->cmdarg_stack), local_switch(p));
+                      p->cmdarg_stack = 0;
+                      p->in_def++;
+                      nvars_block(p);
+                    }
+                ;
+
+defs_head       : keyword_def singleton dot_or_colon
+                    {
+                      p->lstate = EXPR_FNAME;
+                    }
+                    fname
+                    {
+                      $$ = new_sdef(p, $2, $5, nint(p->cmdarg_stack), local_switch(p));
+                      p->cmdarg_stack = 0;
+                      p->in_def++;
+                      p->in_single++;
+                      nvars_block(p);
+                      p->lstate = EXPR_ENDFN; /* force for args */
+                    }
+                ;
+
 expr_value      : expr
                     {
                       if (!$1) $$ = new_nil(p);
@@ -1902,7 +1974,7 @@ mlhs_node       : variable
                     }
                 | primary_value '[' opt_call_args ']'
                     {
-                      $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+                      $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.');
                     }
                 | primary_value call_op tIDENTIFIER
                     {
@@ -1941,7 +2013,7 @@ lhs             : variable
                     }
                 | primary_value '[' opt_call_args ']'
                     {
-                      $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+                      $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.');
                     }
                 | primary_value call_op tIDENTIFIER
                     {
@@ -2029,36 +2101,36 @@ undef_list      : fsym
                     }
                 ;
 
-op              : '|'           { $$ = intern_lit("|");   }
-                | '^'           { $$ = intern_lit("^");   }
-                | '&'           { $$ = intern_lit("&");   }
-                | tCMP          { $$ = intern_lit("<=>"); }
-                | tEQ           { $$ = intern_lit("==");  }
-                | tEQQ          { $$ = intern_lit("==="); }
-                | tMATCH        { $$ = intern_lit("=~");  }
-                | tNMATCH       { $$ = intern_lit("!~");  }
-                | '>'           { $$ = intern_lit(">");   }
-                | tGEQ          { $$ = intern_lit(">=");  }
-                | '<'           { $$ = intern_lit("<");   }
-                | tLEQ          { $$ = intern_lit("<=");  }
-                | tNEQ          { $$ = intern_lit("!=");  }
-                | tLSHFT        { $$ = intern_lit("<<");  }
-                | tRSHFT        { $$ = intern_lit(">>");  }
-                | '+'           { $$ = intern_lit("+");   }
-                | '-'           { $$ = intern_lit("-");   }
-                | '*'           { $$ = intern_lit("*");   }
-                | tSTAR         { $$ = intern_lit("*");   }
-                | '/'           { $$ = intern_lit("/");   }
-                | '%'           { $$ = intern_lit("%");   }
-                | tPOW          { $$ = intern_lit("**");  }
-                | tDSTAR        { $$ = intern_lit("**");  }
-                | '!'           { $$ = intern_lit("!");   }
-                | '~'           { $$ = intern_lit("~");   }
-                | tUPLUS        { $$ = intern_lit("+@");  }
-                | tUMINUS       { $$ = intern_lit("-@");  }
-                | tAREF         { $$ = intern_lit("[]");  }
-                | tASET         { $$ = intern_lit("[]="); }
-                | '`'           { $$ = intern_lit("`");   }
+op              : '|'           { $$ = MRB_QSYM(or);     }
+                | '^'           { $$ = MRB_QSYM(xor);    }
+                | '&'           { $$ = MRB_QSYM(and);    }
+                | tCMP          { $$ = MRB_QSYM(cmp);    }
+                | tEQ           { $$ = MRB_QSYM(eq);     }
+                | tEQQ          { $$ = MRB_QSYM(eqq);    }
+                | tMATCH        { $$ = MRB_QSYM(match);  }
+                | tNMATCH       { $$ = MRB_QSYM(nmatch); }
+                | '>'           { $$ = MRB_QSYM(gt);     }
+                | tGEQ          { $$ = MRB_QSYM(ge);     }
+                | '<'           { $$ = MRB_QSYM(lt);     }
+                | tLEQ          { $$ = MRB_QSYM(le);     }
+                | tNEQ          { $$ = MRB_QSYM(neq);    }
+                | tLSHFT        { $$ = MRB_QSYM(lshift); }
+                | tRSHFT        { $$ = MRB_QSYM(rshift); }
+                | '+'           { $$ = MRB_QSYM(add);    }
+                | '-'           { $$ = MRB_QSYM(sub);    }
+                | '*'           { $$ = MRB_QSYM(mul);    }
+                | tSTAR         { $$ = MRB_QSYM(mul);    }
+                | '/'           { $$ = MRB_QSYM(div);    }
+                | '%'           { $$ = MRB_QSYM(mod);    }
+                | tPOW          { $$ = MRB_QSYM(pow);    }
+                | tDSTAR        { $$ = MRB_QSYM(pow);    }
+                | '!'           { $$ = MRB_QSYM(not);    }
+                | '~'           { $$ = MRB_QSYM(neg);    }
+                | tUPLUS        { $$ = MRB_QSYM(plus);   }
+                | tUMINUS       { $$ = MRB_QSYM(minus);  }
+                | tAREF         { $$ = MRB_QSYM(aref);   }
+                | tASET         { $$ = MRB_QSYM(aset);   }
+                | '`'           { $$ = MRB_QSYM(tick);   }
                 ;
 
 reswords        : keyword__LINE__ | keyword__FILE__ | keyword__ENCODING__
@@ -2085,7 +2157,7 @@ arg             : lhs '=' arg_rhs
                     }
                 | primary_value '[' opt_call_args ']' tOP_ASGN arg_rhs
                     {
-                      $$ = new_op_asgn(p, new_call(p, $1, intern_lit("[]"), $3, '.'), $5, $6);
+                      $$ = new_op_asgn(p, new_call(p, $1, MRB_QSYM(aref), $3, '.'), $5, $6);
                     }
                 | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
                     {
@@ -2246,6 +2318,42 @@ arg             : lhs '=' arg_rhs
                     {
                       $$ = new_if(p, cond($1), $3, $6);
                     }
+                | defn_head f_arglist_paren '=' arg
+                    {
+                      $$ = $1;
+                      void_expr_error(p, $4);
+                      defn_setup(p, $$, $2, $4);
+                      nvars_unnest(p);
+                      p->in_def--;
+                    }
+                | defn_head f_arglist_paren '=' arg modifier_rescue arg
+                    {
+                      $$ = $1;
+                      void_expr_error(p, $4);
+                      void_expr_error(p, $6);
+                      defn_setup(p, $$, $2, new_mod_rescue(p, $4, $6));
+                      nvars_unnest(p);
+                      p->in_def--;
+                    }
+                | defs_head f_arglist_paren '=' arg
+                    {
+                      $$ = $1;
+                      void_expr_error(p, $4);
+                      defs_setup(p, $$, $2, $4);
+                      nvars_unnest(p);
+                      p->in_def--;
+                      p->in_single--;
+                    }
+                | defs_head f_arglist_paren '=' arg modifier_rescue arg
+                    {
+                      $$ = $1;
+                      void_expr_error(p, $4);
+                      void_expr_error(p, $6);
+                      defs_setup(p, $$, $2, new_mod_rescue(p, $4, $6));
+                      nvars_unnest(p);
+                      p->in_def--;
+                      p->in_single--;
+                    }
                 | primary
                     {
                       $$ = $1;
@@ -2288,16 +2396,16 @@ paren_args      : '(' opt_call_args ')'
                 | '(' tDOT3 rparen
                     {
 #if 1
-                      mrb_sym r = mrb_intern_lit(p->mrb, "*");
-                      mrb_sym b = mrb_intern_lit(p->mrb, "&");
+                      mrb_sym r = MRB_QSYM(mul);
+                      mrb_sym b = MRB_QSYM(and);
                       if (local_var_p(p, r)  && local_var_p(p, b)) {
                         $$ = cons(list1(new_splat(p, new_lvar(p, r))),
                                   new_block_arg(p, new_lvar(p, b)));
                       }
 #else
-                      mrb_sym r = mrb_intern_lit(p->mrb, "*");
-                      mrb_sym k = mrb_intern_lit(p->mrb, "**");
-                      mrb_sym b = mrb_intern_lit(p->mrb, "&");
+                      mrb_sym r = MRB_QSYM(mul);
+                      mrb_sym k = MRB_QSYM(pow);
+                      mrb_sym b = MRB_QSYM(and);
                       if (local_var_p(p, r) && local_var_p(p, k) && local_var_p(p, b)) {
                         $$ = cons(list2(new_splat(p, new_lvar(p, r)),
                                         new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k))))),
@@ -2645,50 +2753,26 @@ primary         : literal
                       local_resume(p, $<nd>3);
                       nvars_unnest(p);
                     }
-                | keyword_def fname
-                    {
-                      $<stack>$ = p->cmdarg_stack;
-                      p->cmdarg_stack = 0;
-                    }
-                    {
-                      p->in_def++;
-                      $<nd>$ = local_switch(p);
-                      nvars_block(p);
-                    }
+                | defn_head
                   f_arglist
                   bodystmt
                   keyword_end
                     {
-                      $$ = new_def(p, $2, $5, $6);
-                      SET_LINENO($$, $1);
-                      local_resume(p, $<nd>4);
+                      $$ = $1;
+                      defn_setup(p, $$, $2, $3);
                       nvars_unnest(p);
                       p->in_def--;
-                      p->cmdarg_stack = $<stack>3;
-                    }
-                | keyword_def singleton dot_or_colon
-                    {
-                      p->lstate = EXPR_FNAME;
-                      $<stack>$ = p->cmdarg_stack;
-                      p->cmdarg_stack = 0;
-                    }
-                    fname
-                    {
-                      p->in_single++;
-                      p->lstate = EXPR_ENDFN; /* force for args */
-                      $<nd>$ = local_switch(p);
-                      nvars_block(p);
                     }
+                | defs_head
                   f_arglist
                   bodystmt
                   keyword_end
                     {
-                      $$ = new_sdef(p, $2, $5, $7, $8);
-                      SET_LINENO($$, $1);
-                      local_resume(p, $<nd>6);
+                      $$ = $1;
+                      defs_setup(p, $$, $2, $3);
                       nvars_unnest(p);
+                      p->in_def--;
                       p->in_single--;
-                      p->cmdarg_stack = $<stack>4;
                     }
                 | keyword_break
                     {
@@ -3010,11 +3094,11 @@ method_call     : operation paren_args
                     }
                 | primary_value call_op paren_args
                     {
-                      $$ = new_call(p, $1, intern_lit("call"), $3, $2);
+                      $$ = new_call(p, $1, MRB_SYM(call), $3, $2);
                     }
                 | primary_value tCOLON2 paren_args
                     {
-                      $$ = new_call(p, $1, intern_lit("call"), $3, tCOLON2);
+                      $$ = new_call(p, $1, MRB_SYM(call), $3, tCOLON2);
                     }
                 | keyword_super paren_args
                     {
@@ -3026,7 +3110,7 @@ method_call     : operation paren_args
                     }
                 | primary_value '[' opt_call_args ']'
                     {
-                      $$ = new_call(p, $1, intern_lit("[]"), $3, '.');
+                      $$ = new_call(p, $1, MRB_QSYM(aref), $3, '.');
                     }
                 ;
 
@@ -3399,7 +3483,7 @@ superclass      : /* term */
                     } */
                 ;
 
-f_arglist       : '(' f_args rparen
+f_arglist_paren : '(' f_args rparen
                     {
                       $$ = $2;
                       p->lstate = EXPR_BEG;
@@ -3409,20 +3493,23 @@ f_arglist       : '(' f_args rparen
                     {
 #if 1
                       /* til real keyword args implemented */
-                      mrb_sym r = mrb_intern_lit(p->mrb, "*");
-                      mrb_sym b = mrb_intern_lit(p->mrb, "&");
+                      mrb_sym r = MRB_QSYM(mul);
+                      mrb_sym b = MRB_QSYM(and);
                       local_add_f(p, r);
                       $$ = new_args(p, 0, 0, r, 0,
                                     new_args_tail(p, 0, 0, b));
 #else
-                      mrb_sym r = mrb_intern_lit(p->mrb, "*");
-                      mrb_sym k = mrb_intern_lit(p->mrb, "**");
-                      mrb_sym b = mrb_intern_lit(p->mrb, "&");
+                      mrb_sym r = MRB_QSYM(mul);
+                      mrb_sym k = MRB_QSYM(pow);
+                      mrb_sym b = MRB_QSYM(and);
                       local_add_f(p, r); local_add_f(p, k);
                       $$ = new_args(p, 0, 0, r, 0,
                                     new_args_tail(p, 0, new_kw_rest_args(p, nsym(k)), b));
 #endif
                     }
+                ;
+
+f_arglist       : f_arglist_paren
                 | f_args term
                     {
                       $$ = $1;
@@ -3580,7 +3667,7 @@ f_args          : f_arg ',' f_optarg ',' f_rest_arg opt_args_tail
                     }
                 | /* none */
                     {
-                      local_add_f(p, mrb_intern_lit(p->mrb, "&"));
+                      local_add_f(p, MRB_QSYM(and));
                       $$ = new_args(p, 0, 0, 0, 0, 0);
                     }
                 ;
@@ -3704,7 +3791,7 @@ f_rest_arg      : restarg_mark tIDENTIFIER
                     }
                 | restarg_mark
                     {
-                      local_add_f(p, mrb_intern_lit(p->mrb, "*"));
+                      local_add_f(p, MRB_QSYM(mul));
                       $$ = -1;
                     }
                 ;
@@ -4961,7 +5048,7 @@ parser_yylex(parser_state *p)
   case '*':
     if ((c = nextc(p)) == '*') {
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit("**");
+        pylval.id = MRB_QSYM(pow);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -4979,7 +5066,7 @@ parser_yylex(parser_state *p)
     }
     else {
       if (c == '=') {
-        pylval.id = intern_lit("*");
+        pylval.id = MRB_QSYM(mul);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -5095,7 +5182,7 @@ parser_yylex(parser_state *p)
     }
     if (c == '<') {
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit("<<");
+        pylval.id = MRB_QSYM(lshift);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -5117,7 +5204,7 @@ parser_yylex(parser_state *p)
     }
     if (c == '>') {
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit(">>");
+        pylval.id = MRB_QSYM(rshift);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -5225,7 +5312,7 @@ parser_yylex(parser_state *p)
     if ((c = nextc(p)) == '&') {
       p->lstate = EXPR_BEG;
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit("&&");
+        pylval.id = MRB_QSYM(andand);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -5237,7 +5324,7 @@ parser_yylex(parser_state *p)
       return tANDDOT;
     }
     else if (c == '=') {
-      pylval.id = intern_lit("&");
+      pylval.id = MRB_QSYM(and);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -5264,7 +5351,7 @@ parser_yylex(parser_state *p)
     if ((c = nextc(p)) == '|') {
       p->lstate = EXPR_BEG;
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit("||");
+        pylval.id = MRB_QSYM(oror);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -5272,7 +5359,7 @@ parser_yylex(parser_state *p)
       return tOROP;
     }
     if (c == '=') {
-      pylval.id = intern_lit("|");
+      pylval.id = MRB_QSYM(or);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -5296,7 +5383,7 @@ parser_yylex(parser_state *p)
       return '+';
     }
     if (c == '=') {
-      pylval.id = intern_lit("+");
+      pylval.id = MRB_QSYM(add);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -5324,7 +5411,7 @@ parser_yylex(parser_state *p)
       return '-';
     }
     if (c == '=') {
-      pylval.id = intern_lit("-");
+      pylval.id = MRB_QSYM(sub);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -5574,7 +5661,7 @@ parser_yylex(parser_state *p)
     }
     tokfix(p);
     if (is_float) {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
       yywarning_s(p, "floating point numbers are not supported", tok(p));
       pylval.nd = new_int(p, "0", 10, 0);
       return tINTEGER;
@@ -5644,7 +5731,7 @@ parser_yylex(parser_state *p)
       return tREGEXP_BEG;
     }
     if ((c = nextc(p)) == '=') {
-      pylval.id = intern_lit("/");
+      pylval.id = MRB_QSYM(div);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -5663,7 +5750,7 @@ parser_yylex(parser_state *p)
 
   case '^':
     if ((c = nextc(p)) == '=') {
-      pylval.id = intern_lit("^");
+      pylval.id = MRB_QSYM(xor);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -5840,7 +5927,7 @@ parser_yylex(parser_state *p)
       }
     }
     if ((c = nextc(p)) == '=') {
-      pylval.id = intern_lit("%");
+      pylval.id = MRB_QSYM(mod);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -6468,7 +6555,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
   struct RClass *target = mrb->object_class;
   struct RProc *proc;
   mrb_value v;
-  unsigned int keep = 0;
+  mrb_int keep = 0;
 
   if (!p) {
     return mrb_undef_value();
@@ -6488,7 +6575,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
     }
     else {
       if (mrb->exc == NULL) {
-        mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
+        mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
       }
       mrb_parser_free(p);
       return mrb_undef_value();
@@ -6498,7 +6585,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
   mrb_parser_free(p);
   if (proc == NULL) {
     if (mrb->exc == NULL) {
-      mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
+      mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
     }
     return mrb_undef_value();
   }
diff --git a/mrbgems/mruby-compiler/core/y.tab.c b/mrbgems/mruby-compiler/core/y.tab.c
index c570fb1d7..b28509d81 100644
--- a/mrbgems/mruby-compiler/core/y.tab.c
+++ b/mrbgems/mruby-compiler/core/y.tab.c
@@ -328,7 +328,7 @@ local_unnest(parser_state *p)
 static mrb_bool
 local_var_p(parser_state *p, mrb_sym sym)
 {
-  struct RProc *u;
+  const struct RProc *u;
   node *l = p->locals;
 
   while (l) {
@@ -342,11 +342,13 @@ local_var_p(parser_state *p, mrb_sym sym)
 
   u = p->upper;
   while (u && !MRB_PROC_CFUNC_P(u)) {
-    struct mrb_irep *ir = u->body.irep;
-    uint_fast16_t n = ir->nlocals;
-    const struct mrb_locals *v = ir->lv;
-    for (; n > 1; n --, v ++) {
-      if (v->name == sym) return TRUE;
+    const struct mrb_irep *ir = u->body.irep;
+    const mrb_sym *v = ir->lv;
+    int i;
+
+    if (!v) break;
+    for (i=0; i < ir->nlocals; i++) {
+      if (v[i] == sym) return TRUE;
     }
     if (MRB_PROC_SCOPE_P(u)) break;
     u = u->upper;
@@ -374,14 +376,14 @@ static void
 local_add_blk(parser_state *p, mrb_sym blk)
 {
   /* allocate register for block */
-  local_add_f(p, blk ? blk : mrb_intern_lit(p->mrb, "&"));
+  local_add_f(p, blk ? blk : MRB_QSYM(and));
 }
 
 static void
 local_add_kw(parser_state *p, mrb_sym kwd)
 {
   /* allocate register for keywords hash */
-  local_add_f(p, kwd ? kwd : mrb_intern_lit(p->mrb, "**"));
+  local_add_f(p, kwd ? kwd : MRB_QSYM(pow));
 }
 
 static node*
@@ -793,7 +795,19 @@ new_module(parser_state *p, node *m, node *b)
 static node*
 new_def(parser_state *p, mrb_sym m, node *a, node *b)
 {
-  return list5((node*)NODE_DEF, nsym(m), locals_node(p), a, b);
+  return list5((node*)NODE_DEF, nsym(m), 0, a, b);
+}
+
+static void
+defn_setup(parser_state *p, node *d, node *a, node *b)
+{
+  node *n = d->cdr->cdr;
+
+  n->car = locals_node(p);
+  p->cmdarg_stack = intn(n->cdr->car);
+  n->cdr->car = a;
+  local_resume(p, n->cdr->cdr->car);
+  n->cdr->cdr->car = b;
 }
 
 /* (:sdef obj m lv (arg . body)) */
@@ -801,7 +815,19 @@ static node*
 new_sdef(parser_state *p, node *o, mrb_sym m, node *a, node *b)
 {
   void_expr_error(p, o);
-  return list6((node*)NODE_SDEF, o, nsym(m), locals_node(p), a, b);
+  return list6((node*)NODE_SDEF, o, nsym(m), 0, a, b);
+}
+
+static void
+defs_setup(parser_state *p, node *d, node *a, node *b)
+{
+  node *n = d->cdr->cdr->cdr;
+
+  n->car = locals_node(p);
+  p->cmdarg_stack = intn(n->cdr->car);
+  n->cdr->car = a;
+  local_resume(p, n->cdr->cdr->car);
+  n->cdr->cdr->car = b;
 }
 
 /* (:arg . sym) */
@@ -995,13 +1021,13 @@ new_op_asgn(parser_state *p, node *a, mrb_sym op, node *b)
 static node*
 new_imaginary(parser_state *p, node *imaginary)
 {
-  return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Complex"), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
+  return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Complex), list1(list2(list3((node*)NODE_INT, (node*)strdup("0"), nint(10)), imaginary)), 1);
 }
 
 static node*
 new_rational(parser_state *p, node *rational)
 {
-  return new_call(p, new_const(p, intern_lit("Kernel")), intern_lit("Rational"), list1(list1(rational)), 1);
+  return new_call(p, new_const(p, MRB_SYM(Kernel)), MRB_SYM(Rational), list1(list1(rational)), 1);
 }
 
 /* (:int . i) */
@@ -1018,7 +1044,7 @@ new_int(parser_state *p, const char *s, int base, int suffix)
   return result;
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /* (:float . i) */
 static node*
 new_float(parser_state *p, const char *s, int suffix)
@@ -1404,7 +1430,7 @@ heredoc_end(parser_state *p)
 /* xxx ----------------------------- */
 
 
-#line 1408 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 1434 "mrbgems/mruby-compiler/core/y.tab.c"
 
 # ifndef YY_CAST
 #  ifdef __cplusplus
@@ -1574,7 +1600,7 @@ extern int yydebug;
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 union YYSTYPE
 {
-#line 1350 "mrbgems/mruby-compiler/core/parse.y"
+#line 1376 "mrbgems/mruby-compiler/core/parse.y"
 
     node *nd;
     mrb_sym id;
@@ -1582,7 +1608,7 @@ union YYSTYPE
     stack_type stack;
     const struct vtable *vars;
 
-#line 1586 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 1612 "mrbgems/mruby-compiler/core/y.tab.c"
 
 };
 typedef union YYSTYPE YYSTYPE;
@@ -1900,16 +1926,16 @@ union yyalloc
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  3
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   11586
+#define YYLAST   11948
 
 /* YYNTOKENS -- Number of terminals.  */
 #define YYNTOKENS  147
 /* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  176
+#define YYNNTS  177
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  594
+#define YYNRULES  603
 /* YYNSTATES -- Number of states.  */
-#define YYNSTATES  1034
+#define YYNSTATES  1054
 
 #define YYUNDEFTOK  2
 #define YYMAXUTOK   375
@@ -1968,66 +1994,67 @@ static const yytype_uint8 yytranslate[] =
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_int16 yyrline[] =
 {
-       0,  1508,  1508,  1508,  1519,  1525,  1529,  1534,  1538,  1544,
-    1546,  1545,  1559,  1586,  1592,  1596,  1601,  1605,  1611,  1611,
-    1615,  1619,  1623,  1627,  1631,  1635,  1639,  1644,  1645,  1649,
-    1653,  1657,  1661,  1664,  1668,  1672,  1676,  1680,  1684,  1689,
-    1693,  1700,  1701,  1705,  1709,  1710,  1714,  1718,  1722,  1726,
-    1729,  1738,  1739,  1742,  1743,  1750,  1749,  1764,  1768,  1773,
-    1777,  1782,  1786,  1791,  1795,  1799,  1803,  1807,  1813,  1817,
-    1823,  1824,  1830,  1834,  1838,  1842,  1846,  1850,  1854,  1858,
-    1862,  1866,  1872,  1873,  1879,  1883,  1889,  1893,  1899,  1903,
-    1907,  1911,  1915,  1919,  1925,  1931,  1938,  1942,  1946,  1950,
-    1954,  1958,  1964,  1970,  1975,  1981,  1985,  1988,  1992,  1996,
-    2003,  2004,  2005,  2006,  2011,  2018,  2019,  2022,  2026,  2026,
-    2032,  2033,  2034,  2035,  2036,  2037,  2038,  2039,  2040,  2041,
-    2042,  2043,  2044,  2045,  2046,  2047,  2048,  2049,  2050,  2051,
-    2052,  2053,  2054,  2055,  2056,  2057,  2058,  2059,  2060,  2061,
-    2064,  2064,  2064,  2065,  2065,  2066,  2066,  2066,  2067,  2067,
-    2067,  2067,  2068,  2068,  2068,  2069,  2069,  2069,  2070,  2070,
-    2070,  2070,  2071,  2071,  2071,  2071,  2072,  2072,  2072,  2072,
-    2073,  2073,  2073,  2073,  2074,  2074,  2074,  2074,  2075,  2075,
-    2078,  2082,  2086,  2090,  2094,  2098,  2102,  2107,  2112,  2117,
-    2121,  2125,  2129,  2133,  2137,  2141,  2145,  2149,  2153,  2157,
-    2161,  2165,  2169,  2173,  2177,  2181,  2185,  2189,  2193,  2197,
+       0,  1534,  1534,  1534,  1545,  1551,  1555,  1560,  1564,  1570,
+    1572,  1571,  1585,  1612,  1618,  1622,  1627,  1631,  1637,  1637,
+    1641,  1645,  1649,  1653,  1657,  1661,  1665,  1670,  1671,  1675,
+    1679,  1683,  1687,  1688,  1691,  1696,  1701,  1705,  1711,  1715,
+    1719,  1723,  1727,  1731,  1736,  1740,  1747,  1748,  1752,  1756,
+    1757,  1761,  1765,  1769,  1773,  1777,  1787,  1786,  1801,  1810,
+    1811,  1814,  1815,  1822,  1821,  1836,  1840,  1845,  1849,  1854,
+    1858,  1863,  1867,  1871,  1875,  1879,  1885,  1889,  1895,  1896,
+    1902,  1906,  1910,  1914,  1918,  1922,  1926,  1930,  1934,  1938,
+    1944,  1945,  1951,  1955,  1961,  1965,  1971,  1975,  1979,  1983,
+    1987,  1991,  1997,  2003,  2010,  2014,  2018,  2022,  2026,  2030,
+    2036,  2042,  2047,  2053,  2057,  2060,  2064,  2068,  2075,  2076,
+    2077,  2078,  2083,  2090,  2091,  2094,  2098,  2098,  2104,  2105,
+    2106,  2107,  2108,  2109,  2110,  2111,  2112,  2113,  2114,  2115,
+    2116,  2117,  2118,  2119,  2120,  2121,  2122,  2123,  2124,  2125,
+    2126,  2127,  2128,  2129,  2130,  2131,  2132,  2133,  2136,  2136,
+    2136,  2137,  2137,  2138,  2138,  2138,  2139,  2139,  2139,  2139,
+    2140,  2140,  2140,  2141,  2141,  2141,  2142,  2142,  2142,  2142,
+    2143,  2143,  2143,  2143,  2144,  2144,  2144,  2144,  2145,  2145,
+    2145,  2145,  2146,  2146,  2146,  2146,  2147,  2147,  2150,  2154,
+    2158,  2162,  2166,  2170,  2174,  2179,  2184,  2189,  2193,  2197,
     2201,  2205,  2209,  2213,  2217,  2221,  2225,  2229,  2233,  2237,
-    2241,  2245,  2249,  2255,  2256,  2261,  2265,  2272,  2276,  2284,
-    2288,  2314,  2315,  2318,  2319,  2320,  2325,  2330,  2337,  2343,
-    2348,  2353,  2358,  2365,  2365,  2376,  2382,  2386,  2392,  2393,
-    2396,  2402,  2408,  2413,  2420,  2425,  2430,  2437,  2438,  2439,
-    2440,  2441,  2442,  2443,  2444,  2448,  2453,  2452,  2464,  2468,
-    2463,  2473,  2473,  2477,  2481,  2485,  2489,  2494,  2499,  2503,
-    2507,  2511,  2515,  2519,  2520,  2526,  2532,  2525,  2544,  2552,
-    2560,  2560,  2560,  2567,  2567,  2567,  2574,  2580,  2585,  2587,
-    2584,  2596,  2594,  2612,  2617,  2610,  2634,  2632,  2649,  2653,
-    2648,  2670,  2676,  2669,  2693,  2697,  2701,  2705,  2711,  2718,
-    2719,  2720,  2723,  2724,  2727,  2728,  2736,  2737,  2743,  2747,
-    2750,  2754,  2758,  2762,  2767,  2771,  2775,  2779,  2785,  2784,
-    2794,  2798,  2802,  2806,  2812,  2817,  2822,  2826,  2830,  2834,
-    2838,  2842,  2846,  2850,  2854,  2858,  2862,  2866,  2870,  2874,
-    2878,  2884,  2889,  2896,  2896,  2900,  2905,  2912,  2916,  2922,
-    2923,  2926,  2931,  2934,  2938,  2944,  2948,  2955,  2954,  2969,
-    2979,  2983,  2988,  2995,  2999,  3003,  3007,  3011,  3015,  3019,
-    3023,  3027,  3034,  3033,  3048,  3047,  3063,  3071,  3080,  3083,
-    3090,  3093,  3097,  3098,  3101,  3105,  3108,  3112,  3115,  3116,
-    3117,  3118,  3121,  3122,  3128,  3129,  3130,  3134,  3140,  3141,
-    3147,  3152,  3151,  3162,  3166,  3172,  3176,  3182,  3186,  3192,
-    3195,  3196,  3199,  3205,  3211,  3212,  3215,  3222,  3221,  3235,
-    3239,  3246,  3251,  3258,  3264,  3265,  3266,  3267,  3268,  3272,
-    3278,  3282,  3288,  3289,  3290,  3294,  3300,  3304,  3308,  3312,
-    3316,  3322,  3326,  3332,  3336,  3340,  3344,  3348,  3352,  3360,
-    3367,  3378,  3379,  3383,  3387,  3386,  3402,  3408,  3426,  3432,
-    3438,  3444,  3451,  3456,  3463,  3467,  3473,  3477,  3483,  3484,
-    3487,  3491,  3497,  3501,  3505,  3509,  3515,  3520,  3525,  3529,
-    3533,  3537,  3541,  3545,  3549,  3553,  3557,  3561,  3565,  3569,
-    3573,  3577,  3582,  3588,  3593,  3598,  3603,  3608,  3615,  3619,
-    3626,  3631,  3630,  3642,  3646,  3652,  3660,  3668,  3676,  3680,
-    3686,  3690,  3696,  3697,  3700,  3705,  3712,  3713,  3716,  3722,
-    3726,  3732,  3737,  3737,  3762,  3763,  3769,  3774,  3780,  3781,
-    3784,  3790,  3795,  3805,  3812,  3813,  3814,  3817,  3818,  3819,
-    3820,  3823,  3824,  3825,  3828,  3829,  3832,  3836,  3842,  3843,
-    3849,  3850,  3853,  3854,  3857,  3860,  3861,  3862,  3865,  3866,
-    3867,  3870,  3877,  3878,  3882
+    2241,  2245,  2249,  2253,  2257,  2261,  2265,  2269,  2273,  2277,
+    2281,  2285,  2289,  2293,  2297,  2301,  2305,  2309,  2313,  2317,
+    2321,  2329,  2338,  2347,  2357,  2363,  2364,  2369,  2373,  2380,
+    2384,  2392,  2396,  2422,  2423,  2426,  2427,  2428,  2433,  2438,
+    2445,  2451,  2456,  2461,  2466,  2473,  2473,  2484,  2490,  2494,
+    2500,  2501,  2504,  2510,  2516,  2521,  2528,  2533,  2538,  2545,
+    2546,  2547,  2548,  2549,  2550,  2551,  2552,  2556,  2561,  2560,
+    2572,  2576,  2571,  2581,  2581,  2585,  2589,  2593,  2597,  2602,
+    2607,  2611,  2615,  2619,  2623,  2627,  2628,  2634,  2640,  2633,
+    2652,  2660,  2668,  2668,  2668,  2675,  2675,  2675,  2682,  2688,
+    2693,  2695,  2692,  2704,  2702,  2720,  2725,  2718,  2742,  2740,
+    2756,  2766,  2777,  2781,  2785,  2789,  2795,  2802,  2803,  2804,
+    2807,  2808,  2811,  2812,  2820,  2821,  2827,  2831,  2834,  2838,
+    2842,  2846,  2851,  2855,  2859,  2863,  2869,  2868,  2878,  2882,
+    2886,  2890,  2896,  2901,  2906,  2910,  2914,  2918,  2922,  2926,
+    2930,  2934,  2938,  2942,  2946,  2950,  2954,  2958,  2962,  2968,
+    2973,  2980,  2980,  2984,  2989,  2996,  3000,  3006,  3007,  3010,
+    3015,  3018,  3022,  3028,  3032,  3039,  3038,  3053,  3063,  3067,
+    3072,  3079,  3083,  3087,  3091,  3095,  3099,  3103,  3107,  3111,
+    3118,  3117,  3132,  3131,  3147,  3155,  3164,  3167,  3174,  3177,
+    3181,  3182,  3185,  3189,  3192,  3196,  3199,  3200,  3201,  3202,
+    3205,  3206,  3212,  3213,  3214,  3218,  3224,  3225,  3231,  3236,
+    3235,  3246,  3250,  3256,  3260,  3266,  3270,  3276,  3279,  3280,
+    3283,  3289,  3295,  3296,  3299,  3306,  3305,  3319,  3323,  3330,
+    3335,  3342,  3348,  3349,  3350,  3351,  3352,  3356,  3362,  3366,
+    3372,  3373,  3374,  3378,  3384,  3388,  3392,  3396,  3400,  3406,
+    3410,  3416,  3420,  3424,  3428,  3432,  3436,  3444,  3451,  3462,
+    3463,  3467,  3471,  3470,  3486,  3492,  3512,  3513,  3519,  3525,
+    3531,  3538,  3543,  3550,  3554,  3560,  3564,  3570,  3571,  3574,
+    3578,  3584,  3588,  3592,  3596,  3602,  3607,  3612,  3616,  3620,
+    3624,  3628,  3632,  3636,  3640,  3644,  3648,  3652,  3656,  3660,
+    3664,  3669,  3675,  3680,  3685,  3690,  3695,  3702,  3706,  3713,
+    3718,  3717,  3729,  3733,  3739,  3747,  3755,  3763,  3767,  3773,
+    3777,  3783,  3784,  3787,  3792,  3799,  3800,  3803,  3809,  3813,
+    3819,  3824,  3824,  3849,  3850,  3856,  3861,  3867,  3868,  3871,
+    3877,  3882,  3892,  3899,  3900,  3901,  3904,  3905,  3906,  3907,
+    3910,  3911,  3912,  3915,  3916,  3919,  3923,  3929,  3930,  3936,
+    3937,  3940,  3941,  3944,  3947,  3948,  3949,  3952,  3953,  3954,
+    3957,  3964,  3965,  3969
 };
 #endif
 
@@ -2065,33 +2092,33 @@ static const char *const yytname[] =
   "'~'", "tLAST_TOKEN", "'{'", "'}'", "'['", "']'", "','", "'`'", "'('",
   "')'", "';'", "'.'", "'\\n'", "$accept", "program", "$@1",
   "top_compstmt", "top_stmts", "top_stmt", "@2", "bodystmt", "compstmt",
-  "stmts", "stmt", "$@3", "command_asgn", "command_rhs", "expr",
-  "expr_value", "command_call", "block_command", "cmd_brace_block", "$@4",
-  "command", "mlhs", "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_list",
-  "mlhs_post", "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym",
-  "undef_list", "$@5", "op", "reswords", "arg", "aref_args", "arg_rhs",
-  "paren_args", "opt_paren_args", "opt_call_args", "call_args",
-  "command_args", "@6", "block_arg", "opt_block_arg", "comma", "args",
-  "mrhs", "primary", "@7", "@8", "$@9", "$@10", "@11", "@12", "$@13",
-  "$@14", "$@15", "$@16", "$@17", "$@18", "@19", "@20", "@21", "@22",
-  "@23", "@24", "@25", "@26", "primary_value", "then", "do", "if_tail",
-  "opt_else", "for_var", "f_margs", "$@27", "block_args_tail",
-  "opt_block_args_tail", "block_param", "opt_block_param",
-  "block_param_def", "$@28", "opt_bv_decl", "bv_decls", "bvar",
-  "f_larglist", "lambda_body", "do_block", "$@29", "block_call",
-  "method_call", "brace_block", "@30", "@31", "case_body", "cases",
+  "stmts", "stmt", "$@3", "rassign", "command_asgn", "command_rhs", "expr",
+  "defn_head", "defs_head", "$@4", "expr_value", "command_call",
+  "block_command", "cmd_brace_block", "$@5", "command", "mlhs",
+  "mlhs_inner", "mlhs_basic", "mlhs_item", "mlhs_list", "mlhs_post",
+  "mlhs_node", "lhs", "cname", "cpath", "fname", "fsym", "undef_list",
+  "$@6", "op", "reswords", "arg", "aref_args", "arg_rhs", "paren_args",
+  "opt_paren_args", "opt_call_args", "call_args", "command_args", "@7",
+  "block_arg", "opt_block_arg", "comma", "args", "mrhs", "primary", "@8",
+  "@9", "$@10", "$@11", "@12", "@13", "$@14", "$@15", "$@16", "$@17",
+  "$@18", "$@19", "@20", "@21", "@22", "@23", "primary_value", "then",
+  "do", "if_tail", "opt_else", "for_var", "f_margs", "$@24",
+  "block_args_tail", "opt_block_args_tail", "block_param",
+  "opt_block_param", "block_param_def", "$@25", "opt_bv_decl", "bv_decls",
+  "bvar", "f_larglist", "lambda_body", "do_block", "$@26", "block_call",
+  "method_call", "brace_block", "@27", "@28", "case_body", "cases",
   "opt_rescue", "exc_list", "exc_var", "opt_ensure", "literal", "string",
-  "string_fragment", "string_rep", "string_interp", "@32", "xstring",
+  "string_fragment", "string_rep", "string_interp", "@29", "xstring",
   "regexp", "heredoc", "heredoc_bodies", "heredoc_body",
-  "heredoc_string_rep", "heredoc_string_interp", "@33", "words", "symbol",
+  "heredoc_string_rep", "heredoc_string_interp", "@30", "words", "symbol",
   "basic_symbol", "sym", "symbols", "numeric", "variable", "var_lhs",
-  "var_ref", "backref", "superclass", "$@34", "f_arglist", "f_label",
-  "f_kw", "f_block_kw", "f_block_kwarg", "f_kwarg", "kwrest_mark",
-  "f_kwrest", "args_tail", "opt_args_tail", "f_args", "f_bad_arg",
-  "f_norm_arg", "f_arg_item", "@35", "f_arg", "f_opt_asgn", "f_opt",
-  "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
+  "var_ref", "backref", "superclass", "$@31", "f_arglist_paren",
+  "f_arglist", "f_label", "f_kw", "f_block_kw", "f_block_kwarg", "f_kwarg",
+  "kwrest_mark", "f_kwrest", "args_tail", "opt_args_tail", "f_args",
+  "f_bad_arg", "f_norm_arg", "f_arg_item", "@32", "f_arg", "f_opt_asgn",
+  "f_opt", "f_block_opt", "f_block_optarg", "f_optarg", "restarg_mark",
   "f_rest_arg", "blkarg_mark", "f_block_arg", "opt_f_block_arg",
-  "singleton", "$@36", "assoc_list", "assocs", "label_tag", "assoc",
+  "singleton", "$@33", "assoc_list", "assocs", "label_tag", "assoc",
   "operation", "operation2", "operation3", "dot_or_colon", "call_op",
   "call_op2", "opt_terms", "opt_nl", "rparen", "trailer", "term", "nl",
   "terms", "none", YY_NULLPTR
@@ -2121,12 +2148,12 @@ static const yytype_int16 yytoknum[] =
 };
 # endif
 
-#define YYPACT_NINF (-829)
+#define YYPACT_NINF (-870)
 
 #define yypact_value_is_default(Yyn) \
   ((Yyn) == YYPACT_NINF)
 
-#define YYTABLE_NINF (-595)
+#define YYTABLE_NINF (-604)
 
 #define yytable_value_is_error(Yyn) \
   ((Yyn) == YYTABLE_NINF)
@@ -2135,110 +2162,112 @@ static const yytype_int16 yytoknum[] =
      STATE-NUM.  */
 static const yytype_int16 yypact[] =
 {
-    -829,   164,  2491,  -829,  7022,  8994,  9330,  5100,  -829,  8646,
-    8646,  -829,  -829,  9106,  6520,  4956,  7370,  7370,  -829,  -829,
-    7370,  2735,  5870,  -829,  -829,  -829,  -829,   -39,  6520,  -829,
-      36,  -829,  -829,  -829,  5240,  5380,  -829,  -829,  5520,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,    20,  8762,  8762,   129,
-    4227,  1481,  7602,  7950,  6798,  -829,  6242,   614,   927,  1024,
-    1126,   839,  -829,   410,  8878,  8762,  -829,   852,  -829,  1251,
-    -829,   448,  -829,  -829,   166,   171,  -829,    80,  9218,  -829,
-     198, 11318,   299,   402,    21,    59,  -829,   354,  -829,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,  -829,   203,   165,  -829,
-     340,   137,  -829,  -829,  -829,  -829,  -829,   159,   159,   177,
-      72,   552,  -829,  8646,    99,  4344,   607,  -829,   200,  -829,
-     494,  -829,  -829,   137,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,    33,    44,    47,   101,  -829,  -829,  -829,  -829,
-    -829,  -829,   170,   218,   219,   227,  -829,   229,  -829,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,  -829,   240,  3417,   270,   448,    83,   225,   526,
-      61,   247,    86,    83,  8646,  8646,   539,   306,  -829,  -829,
-     609,   329,    95,   110,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,  -829,  6381,  -829,  -829,   253,  -829,  -829,  -829,
-    -829,  -829,  -829,   852,  -829,   264,  -829,   386,  -829,  -829,
-     852,  2601,  8762,  8762,  8762,  8762,  -829, 11297,  -829,  -829,
-     271,   361,   271,  -829,  -829,  -829,  7138,  -829,  -829,  -829,
-    7370,  -829,  -829,  -829,  4956,  8646,  -829,  -829,   286,  4461,
-    -829,   796,   355,   398,  7254,  4227,   302,   852,  1251,   852,
-     323,  -829,  7254,   852,   325,  1517,  1517,  -829, 11297,   316,
-    1517,  -829,   421,  9442,   370,   798,   826,   859,  1597,  -829,
-    -829,  -829,  -829,  1166,  -829,  -829,  -829,  -829,  -829,  -829,
-     679,   749,  -829,  -829,  1186,  -829,  1195,  -829,  1257,  -829,
-     860,   444,   446,  -829,  -829,  -829,  -829,  4722,  8646,  8646,
-    8646,  8646,  7254,  8646,  8646,  -829,  -829,  8066,  -829,  4227,
-    6910,   392,  8066,  8762,  8762,  8762,  8762,  8762,  8762,  8762,
-    8762,  8762,  8762,  8762,  8762,  8762,  8762,  8762,  8762,  8762,
-    8762,  8762,  8762,  8762,  8762,  8762,  8762,  8762,  8762,  9714,
-    -829,  7370,  -829,  9798,  -829,  -829, 10974,  -829,  -829,  -829,
-    -829,  8878,  8878,  -829,   428,  -829,   448,  -829,   961,  -829,
-    -829,  -829,  -829,  -829,  9882,  7370,  9966,  3417,  8646,  -829,
-    -829,  -829,  -829,   522,   528,   149,  -829,  3561,   533,  8762,
-   10050,  7370, 10134,  8762,  8762,  3849,   126,   126,   113, 10218,
-    7370, 10302,  -829,   501,  -829,  4461,   386,  -829,  -829,  8182,
-     542,  -829,   679,  8762, 11318, 11318, 11318,  8762,   476,  -829,
-    7486,  -829,  8762,  -829,  7718,   852,   425,   852,   271,   271,
-    -829,  -829,   745,   431,  -829,  -829,  6520,  3966,   443, 10050,
-   10134,  8762,  1251,   852,  -829,  -829,  4839,   445,  1251,  -829,
-    -829,  7834,  -829,   852,  7950,  -829,  -829,  -829,   961,    80,
-    9442,  -829,  9442, 10386,  7370, 10470,    30,  -829,  -829,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  1719,
-    -829,  8762,  -829,   451,   554,   472,  -829,  -829,  -829,  -829,
-    -829,   479,  8762,  -829,   497,   596,   511,   608,  -829,  -829,
-    1283,  4461,   679,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-    8762,  8762,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-     153,  8762,  -829, 11121,   271,  -829,   852,  9442,   532,  -829,
-    -829,  -829,   570,   572,  2302,  -829,  -829,   976,   180,   355,
-    2331,  2331,  2331,  2331,  1479,  1479, 11455, 11395,  2331,  2331,
-   11378, 11378,   671,   671, 11061,  1479,  1479,  1462,  1462,  1490,
-     175,   175,   355,   355,   355,  2869,  5986,  3137,  6102,  -829,
-     159,  -829,   550,   437,  -829,   563,  -829,  -829,  5870,  -829,
-    -829,  2061,   153,   153,  -829, 11044,  -829,  -829,  -829,  -829,
-    -829,   852,  8646,  3417,   736,   813,  -829,   159,   560,   159,
-     699,   745,  1650,  6659,  -829,  8298,   706,  -829,   690,  -829,
-    5636,  5753,   605,   268,   276,   706,  -829,  -829,  -829,  -829,
-      79,    88,   613,   121,   140,  8646,  6520,   616,   740, 11318,
-     450,  -829,   679, 11318, 11318,   679,  8762, 11297,  -829,   271,
-   11318,  -829,  -829,  -829,  -829,  7486,  7718,  -829,  -829,  -829,
-     623,  -829,  -829,   136,  1251,   852,  1517,   392,  -829,   736,
-     813,   626,   959,  1023,  -829,  -829,  1123,   622,    77, 11318,
-     768,  -829,  -829,  -829,   201,  -829,  1719,  -829, 11318,  1719,
-    -829,  -829,  1907,  -829,  -829,  -829,   637,  -829,   355,   355,
-    -829,  1719,  3417,  -829,  -829, 11140,  8414,  -829,  -829,  9442,
-    7254,  8878,  8762, 10554,  7370, 10638,    70,  8878,  8878,  -829,
-     428,   672,  8878,  8878,  -829,   428,    59,   166,  3417,  4461,
-     153,  -829,   852,   762,  -829,  -829,  -829,  1826,  3417,   852,
-    -829, 11121,  -829,   689,  -829,  4110,   774,  -829,  8646,   779,
-    -829,  8762,  8762,   358,  8762,  8762,   800,  4605,  4605,   156,
-     126,  -829,  -829,  -829,  8530,  3705,   679, 11318,  -829,   271,
-    -829,  -829,  -829,   192,  -829,   104,   852,   676,   674,   678,
-    3417,  4461,  -829,   766,  -829,   472,  -829,  -829,  -829,   684,
-     686,   687,  -829,   691,   766,   687,  -829,  -829,   622,   622,
-    9554,  -829,   694,   472,   695,  9554,  -829,   698,   701,  -829,
-     835,  8762, 11209,  -829,  -829, 11318,  3003,  3271,   712,   408,
-     432,  8762,  8762,  -829,  -829,  -829,  -829,  -829,  8878,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,   840,   722,  4461,  3417,
-    -829,  -829,   852,   852,   845,  -829,  1650,  9666,    83,  -829,
-    -829,  4605,  -829,  -829,    83,  -829,  8762,  -829,   855,   856,
-    -829, 11318,   193,  7718,  -829,   733,  -829,  1530,  -829,   680,
-     868,   753,  -829,  1719,  -829,  1907,  -829,  1907,  -829,  1907,
-    -829,  -829,   769,   771,   837,   995,   768,  -829,  -829,  1282,
-    -829,   995,  1719,  -829,  1907,  -829,  -829, 11228,   439, 11318,
-   11318,  -829,  -829,  -829,  -829,   761,   896,  -829,  -829,  -829,
-    3417,   862,  -829,  1028,   826,   859,  3417,  -829,  3561,  -829,
-    -829,  4605,  -829,  -829,  -829,  1585,  1585,   547,  -829,    22,
-    -829,  -829,  -829,  -829,   687,   778,   687,   687,  -829,  -829,
-    -829, 10722,  -829,   472,   768,  -829,  -829,   780,   792,   793,
-    -829,   799,   793,  -829,  -829,   913,   961, 10806,  7370, 10890,
-     528,   690,   935,   812,   812,  1585,   823,   680,  -829,  -829,
-    1907,  -829,  -829,  -829,   824,   828,  -829,  1719,  -829,  1907,
-    -829,  1907,  -829,  1907,  -829,  -829,  -829,   736,   813,   834,
-     357,   579,  -829,  -829,  -829,  1585,   812,  1585,  -829,   687,
-     793,   842,   793,   793,   192,   812,  -829,  -829,  1907,  -829,
-    -829,  -829,   793,  -829
+    -870,   123,  2747,  -870,  7459,  9431,  9767,  5537,  -870,  9083,
+    9083,  -870,  -870,  9543,  6957,  5393,  7807,  7807,  -870,  -870,
+    7807,  3172,  6307,  -870,  -870,  -870,  -870,   127,  6957,  -870,
+      78,  -870,  -870,  -870,  5677,  5817,  -870,  -870,  5957,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,    30,  9199,  9199,    95,
+    4664,   906,  8039,  8387,  7235,  -870,  6679,  1068,  1316,  1360,
+    1376,   695,  -870,   125,  9315,  9199,  -870,  1474,  -870,  1634,
+      60,  -870,    75,  1663,  1663,  -870,  -870,   163,    87,  -870,
+      34,  9655,  -870,   114, 11676,   197,   488,   260,    39,  -870,
+     322,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,
+      38,   204,  -870,   241,    22,  -870,  -870,  -870,  -870,  -870,
+      94,    94,   155,   275,   998,  -870,  9083,   263,  4781,   161,
+    1663,  1663,  -870,   180,  -870,   626,  -870,  -870,    22,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,    70,   109,   134,
+     138,  -870,  -870,  -870,  -870,  -870,  -870,   146,   171,   189,
+     201,  -870,   205,  -870,  -870,  -870,  -870,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,   221,  3854,
+     256,    75,   546,   207, 11757,   662,   102,   252,   250,   546,
+    9083,  9083,   823,   292,  -870,  -870,   866,   337,   542,   643,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  6818,
+    -870,  -870,   236,  -870,  -870,  -870,  -870,  -870,  -870,  1474,
+    -870,   483,  -870,   363,  -870,  -870,  1474,  3038,  9199,  9199,
+    9199,  9199,  -870, 11736,  -870,  -870,   259,   349,   259,  -870,
+    -870,  -870,  7575,  -870,  -870,  -870,  7807,  -870,  -870,  -870,
+    5393,  9083,  -870,  -870,   272,  4898,  -870,   902,   344,   305,
+    7691,  4664,   279,  1474,  1634,  1474,   310,  -870,  7691,  1474,
+     316,  1341,  1341,  -870, 11736,   289,  1341,  -870,   391,  9879,
+     325,   936,   999,  1050,  1903,  -870,  -870,  -870,  -870,  1382,
+    -870,  -870,  -870,  -870,  -870,  -870,   498,  1322,  -870,  -870,
+    1398,  -870,  1451,  -870,  1460,  -870,   836,   399,   417,  -870,
+    -870,  -870,  -870,  5159,  9083,  9083,  9083,  9083,  7691,  9543,
+    9083,  9083,    54,  -870,  -870,  -870,  -870,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  -870,  2024,   378,  3854,  9199,  -870,
+     370,   452,   384,  -870,  1474,  -870,  -870,  -870,   386,  9199,
+    -870,   407,   467,   408,   504,  -870,   430,  3854,  -870,  -870,
+    8503,  -870,  4664,  7347,   432,  8503,  9199,  9199,  9199,  9199,
+    9199,  9199,  9199,  9199,  9199,  9199,  9199,  9199,  9199,  9199,
+    9199,  9543,  9199,  9199,  9199,  9199,  9199,  9199,  9199,  9199,
+    9199,  9199,  9199,  1804,  -870,  7807,  -870, 10151,  -870,  -870,
+   11327,  -870,  -870,  -870,  -870,  9315,  9315,  -870,   459,  -870,
+      75,  -870,  1169,  -870,  -870,  -870,  -870,  -870,  -870, 10235,
+    7807, 10319,  3854,  9083,  -870,  -870,  -870,   555,   561,   295,
+    -870,  3998,   562,  9199, 10403,  7807, 10487,  9199,  9199,  4286,
+      88,    88,   827, 10571,  7807, 10655,  -870,   517,  -870,  4898,
+     363,  -870,  -870,  8619,   569,  -870,   498,  9199, 11757, 11757,
+   11757,  9199,   710,  -870,  7923,  -870,  9199,  -870,  8155,  1474,
+     443,  1474,   259,   259,  -870,  -870,    64,   445,  -870,  -870,
+    6957,  4403,   455, 10403, 10487,  9199,  1634,  1474,  -870,  -870,
+    5276,   449,  1634,  -870,  -870,  8271,  -870,  1474,  8387,  -870,
+    -870,  -870,  1169,    34,  9879,  -870,  9879, 10739,  7807, 10823,
+    1771,  -870,  -870,  -870,  1539,  4898,   498,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  9199,  9199,  -870,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  1724,  1474,
+    1474,  9199,   586, 11757,   139,  -870,  -870,  -870,   145,  -870,
+    -870,  1771,  -870, 11757,  1771,  -870,  -870,  1417,  -870,  -870,
+    9199,   591,    48,  9199,  -870, 11500,   259,  -870,  1474,  9879,
+     478,  -870,  -870,  -870,   581,   515,  2373,  -870,  -870,  1180,
+     321,   344,  2795,  2795,  2795,  2795,  1483,  1483, 11817,  2139,
+    2795,  2795,  2250,  2250,   511,   511,  -870,  -870, 11475,  1483,
+    1483,   981,   981,  1377,   178,   178,   344,   344,   344,  3306,
+    6423,  3574,  6539,  -870,    94,  -870,   507,   334,  -870,   366,
+    -870,  -870,  6307,  -870,  -870,  1624,    48,    48,  -870,  2860,
+    -870,  -870,  -870,  -870,  -870,  1474,  9083,  3854,  1191,   100,
+    -870,    94,   508,    94,   633,    64,  7096,  -870,  8735,   640,
+    -870,   208,  -870,  6073,  6190,   521,   351,   439,   640,  -870,
+    -870,  -870,  -870,  1148,   113,   522,  1227,  1261,  9083,  6957,
+     528,   654, 11757,   601,  -870,   498, 11757, 11757,   498,  9199,
+   11736,  -870,   259, 11757,  -870,  -870,  -870,  -870,  7923,  8155,
+    -870,  -870,  -870,   533,  -870,  -870,    90,  1634,  1474,  1341,
+     432,  -870,  1191,   100,   534,  1209,  1306,   532,    81,  -870,
+     548,  -870,   344,   344,  -870,   834,  1474,   543,  -870,  -870,
+   11397,  -870,   631,  -870,   384,  -870,  -870,  -870,   554,   556,
+     558,  -870,   559,   631,   558, 11415,  -870,  -870,  1771,  3854,
+    -870,  -870, 11569,  8851,  -870,  -870,  9879,  7691,  9315,  9199,
+   10907,  7807, 10991,    61,  9315,  9315,  -870,   459,   414,  9315,
+    9315,  -870,   459,    39,   163,  3854,  4898,    48,  -870,  1474,
+     687,  -870,  -870,  -870,  -870, 11500,  -870,   613,  -870,  4547,
+     698,  -870,  9083,   705,  -870,  9199,  9199,   441,  9199,  9199,
+     707,  5042,  5042,   722,    88,  -870,  -870,  -870,  8967,  4142,
+     498, 11757,  -870,   259,  -870,  -870,  -870,   732,   583,   580,
+    3854,  4898,  -870,  -870,  -870,   587,  -870,  1746,  9199,  -870,
+    1771,  -870,  1417,  -870,  1417,  -870,  1417,  -870,  -870,  9199,
+    -870,   532,   532,  9991,  -870,   590,   384,   598,  9991,  -870,
+     600,   604,  -870,   734,  9199, 11588,  -870,  -870, 11757,  3440,
+    3708,   611,   460,   474,  9199,  9199,  -870,  -870,  -870,  -870,
+    -870,  9315,  -870,  -870,  -870,  -870,  -870,  -870,  -870,   738,
+     617,  4898,  3854,  -870,  -870, 10103,   546,  -870,  -870,  5042,
+    -870,  -870,   546,  -870,  9199,  -870,   748,   752,  -870, 11757,
+     112,  8155,  -870,  1287,   755,   635,  1210,  1210,  1010, 11757,
+     558,   636,   558,   558, 11757,   658,   663,   735,  1221,   139,
+    -870,  -870,  1580,  -870,  1221,  1771,  -870,  1417,  -870,  -870,
+   11657,   475, 11757, 11757,  -870,  -870,  -870,  -870,   657,   786,
+     761,  -870,  1272,   999,  1050,  3854,  -870,  3998,  -870,  -870,
+    5042,  -870,  -870,  -870,  -870,    14,  -870,  -870,  -870,  -870,
+     679,   679,  1210,   688,  -870,  1417,  -870,  -870,  -870,  -870,
+    -870,  -870, 11075,  -870,   384,   139,  -870,  -870,   692,   693,
+     694,  -870,   696,   694,  -870,  -870,  1169, 11159,  7807, 11243,
+     561,   208,   826,  1287,  -870,  1210,   679,  1210,   558,   700,
+     708,  -870,  1771,  -870,  1417,  -870,  1417,  -870,  1417,  -870,
+    -870,  1191,   100,   699,  1043,  1087,  -870,  -870,  -870,  -870,
+     679,  -870,   694,   712,   694,   694,   732,  -870,  1417,  -870,
+    -870,  -870,   694,  -870
 };
 
   /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
@@ -2246,156 +2275,158 @@ static const yytype_int16 yypact[] =
      means the default is an error.  */
 static const yytype_int16 yydefact[] =
 {
-       2,     0,     0,     1,     0,     0,     0,     0,   276,     0,
-       0,   300,   303,     0,     0,   580,   324,   325,   326,   327,
-     288,   253,   400,   475,   474,   476,   477,   582,     0,    10,
-       0,   479,   478,   480,   466,   275,   468,   467,   470,   469,
-     462,   463,   424,   425,   481,   482,   274,     0,     0,     0,
-       0,   278,   594,   594,    80,   295,     0,     0,     0,     0,
-       0,     0,   439,     0,     0,     0,     3,   580,     6,     9,
-      27,    32,    44,    52,    51,     0,    68,     0,    72,    82,
-       0,    49,   232,     0,    53,   293,   267,   268,   422,   269,
-     270,   271,   420,   419,   451,   421,   418,   473,     0,   272,
-     273,   253,     5,     8,   324,   325,   288,   594,   400,     0,
-     105,   106,   274,     0,     0,     0,     0,   108,   483,   328,
-       0,   473,   273,     0,   316,   160,   170,   161,   157,   186,
-     187,   188,   189,   168,   183,   176,   166,   165,   181,   164,
-     163,   159,   184,   158,   171,   175,   177,   169,   162,   178,
-     185,   180,   179,   172,   182,   167,   156,   174,   173,   155,
-     153,   154,   150,   151,   152,   110,   112,   111,   145,   146,
-     141,   123,   124,   125,   132,   129,   131,   126,   127,   147,
-     148,   133,   134,   138,   142,   128,   130,   120,   121,   122,
-     135,   136,   137,   139,   140,   143,   144,   149,   552,   318,
-     113,   114,   551,     0,     0,     0,    50,     0,     0,     0,
-     473,     0,   273,     0,     0,     0,   104,     0,   339,   338,
-       0,     0,   473,   273,   179,   172,   182,   167,   150,   151,
-     152,   110,   111,     0,   115,   117,    20,   116,   442,   447,
-     446,   588,   591,   580,   590,     0,   444,     0,   592,   589,
-     581,   564,     0,     0,     0,     0,   248,   260,    66,   252,
-     594,   422,   594,   556,    67,    65,   594,   242,   289,    64,
-       0,   241,   399,    63,   580,     0,   583,    18,     0,     0,
-     209,     0,   210,   285,     0,     0,     0,   580,    15,   580,
-      70,    14,     0,   580,     0,   585,   585,   233,     0,     0,
-     585,   554,     0,     0,    78,     0,    88,    95,   522,   456,
-     455,   457,   458,     0,   454,   453,   437,   431,   430,   433,
-       0,     0,   428,   449,     0,   460,     0,   426,     0,   435,
-       0,   464,   465,    48,   224,   225,     4,   581,     0,     0,
-       0,     0,     0,     0,     0,   387,   389,     0,    84,     0,
-      76,    73,     0,     0,     0,     0,     0,     0,     0,     0,
+       2,     0,     0,     1,     0,     0,     0,     0,   288,     0,
+       0,   312,   315,     0,     0,   589,   332,   333,   334,   335,
+     300,   265,   408,   483,   482,   484,   485,   591,     0,    10,
+       0,   487,   486,   488,   474,   287,   476,   475,   478,   477,
+     470,   471,   432,   433,   489,   490,   286,     0,     0,     0,
+       0,   290,   603,   603,    88,   307,     0,     0,     0,     0,
+       0,     0,   447,     0,     0,     0,     3,   589,     6,     9,
+      32,    27,    33,   531,   531,    49,    60,    59,     0,    76,
+       0,    80,    90,     0,    54,   244,     0,    61,   305,   279,
+     280,   430,   281,   282,   283,   428,   427,   459,   429,   426,
+     481,     0,   284,   285,   265,     5,     8,   332,   333,   300,
+     603,   408,     0,   113,   114,   286,     0,     0,     0,     0,
+     531,   531,   116,   491,   336,     0,   481,   285,     0,   328,
+     168,   178,   169,   165,   194,   195,   196,   197,   176,   191,
+     184,   174,   173,   189,   172,   171,   167,   192,   166,   179,
+     183,   185,   177,   170,   186,   193,   188,   187,   180,   190,
+     175,   164,   182,   181,   163,   161,   162,   158,   159,   160,
+     118,   120,   119,   153,   154,   149,   131,   132,   133,   140,
+     137,   139,   134,   135,   155,   156,   141,   142,   146,   150,
+     136,   138,   128,   129,   130,   143,   144,   145,   147,   148,
+     151,   152,   157,   561,    55,   121,   122,   560,     0,     0,
+       0,    58,     0,     0,    54,     0,   481,     0,   285,     0,
+       0,     0,   112,     0,   347,   346,     0,     0,   104,   111,
+     187,   180,   190,   175,   158,   159,   160,   118,   119,     0,
+     123,   125,    20,   124,   450,   455,   454,   597,   600,   589,
+     599,     0,   452,     0,   601,   598,   590,   573,     0,     0,
+       0,     0,   260,   272,    74,   264,   603,   430,   603,   565,
+      75,    73,   603,   254,   301,    72,     0,   253,   407,    71,
+     589,     0,   592,    18,     0,     0,   217,     0,   218,   297,
+       0,     0,     0,   589,    15,   589,    78,    14,     0,   589,
+       0,   594,   594,   245,     0,     0,   594,   563,     0,     0,
+      86,     0,    96,   103,   531,   464,   463,   465,   466,     0,
+     462,   461,   445,   439,   438,   441,     0,     0,   436,   457,
+       0,   468,     0,   434,     0,   443,     0,   472,   473,    53,
+     232,   233,     4,   590,     0,     0,     0,     0,     0,     0,
+       0,     0,   538,   534,   533,   532,   535,   536,   507,   540,
+     552,   508,   556,   555,   551,   531,   496,     0,   500,   505,
+     603,   510,   603,   530,     0,   537,   539,   542,   516,     0,
+     549,   516,   554,   516,     0,   514,   496,     0,   395,   397,
+       0,    92,     0,    84,    81,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     577,   594,   576,     0,   579,   578,     0,   404,   402,   294,
-     423,     0,     0,   393,    57,   292,   313,   105,   106,   107,
-     464,   465,   484,   311,     0,   594,     0,     0,     0,   319,
-     575,   574,   321,     0,   594,   285,   330,     0,   329,     0,
-       0,   594,     0,     0,     0,     0,     0,     0,   285,     0,
-     594,     0,   308,     0,   118,     0,     0,   443,   445,     0,
-       0,   593,   558,     0,   261,   563,   255,     0,   258,   249,
-       0,   257,     0,   250,     0,   580,     0,   580,   594,   594,
-     243,   254,   580,     0,   291,    47,     0,     0,     0,     0,
-       0,     0,    17,   580,   283,    13,   581,    69,   279,   282,
-     286,   587,   234,   586,   587,   236,   287,   555,    94,    86,
-       0,    81,     0,     0,   594,     0,   529,   525,   524,   523,
-     526,   527,   498,   531,   543,   499,   547,   546,   542,   522,
-     296,   491,   496,   594,   501,   594,   521,   384,   528,   530,
-     533,   507,     0,   540,   507,   545,   507,     0,   505,   459,
-       0,     0,   434,   440,   438,   429,   450,   461,   427,   436,
-       0,     0,     7,    21,    22,    23,    24,    25,    45,    46,
-     594,     0,    28,    30,     0,    31,   580,     0,    74,    85,
-      43,    33,    41,     0,   237,   190,    29,     0,   273,   206,
-     214,   219,   220,   221,   216,   218,   228,   229,   222,   223,
-     199,   200,   226,   227,   582,   215,   217,   211,   212,   213,
-     201,   202,   203,   204,   205,   567,   572,   568,   573,   398,
-     253,   396,     0,   567,   569,   568,   570,   397,   594,   567,
-     568,   253,   594,   594,    34,   237,   191,    40,   198,    55,
-      58,     0,     0,     0,   105,   106,   109,     0,     0,   594,
-       0,   580,   522,     0,   277,   594,   594,   410,   594,   331,
-     571,   284,     0,   567,   568,   594,   333,   301,   332,   304,
-     571,   284,     0,   567,   568,     0,     0,     0,     0,   260,
-       0,   307,   559,   561,   560,     0,     0,   262,   256,   594,
-     562,   557,   240,   239,   244,   245,   247,   290,   584,    19,
-       0,    26,   197,    71,    16,   580,   585,    87,    79,    91,
-      93,     0,    90,    92,   489,   535,     0,   582,     0,   490,
-       0,   503,   550,   500,     0,   504,     0,   514,   536,     0,
-     517,   544,     0,   519,   548,   452,     0,   441,   207,   208,
-     375,   373,     0,   372,   371,   266,     0,    83,    77,     0,
-       0,     0,     0,     0,   594,     0,     0,     0,     0,   395,
-      61,   401,     0,     0,   394,    59,   390,    54,     0,     0,
-     594,   314,     0,     0,   401,   317,   553,   522,     0,     0,
-     322,   411,   412,   594,   413,     0,   594,   336,     0,     0,
-     334,     0,     0,   401,     0,     0,     0,     0,     0,   401,
-       0,   119,   448,   306,     0,     0,   259,   263,   251,   594,
-      11,   280,   235,    89,   529,   347,   580,   340,     0,   377,
-       0,     0,   297,     0,   497,   594,   549,   506,   534,   507,
-     507,   507,   541,   507,   529,   507,   432,   370,   582,   582,
-     493,   494,   594,   594,   355,     0,   538,   355,   355,   353,
-       0,     0,   264,    75,    42,   238,   567,   568,     0,   567,
-     568,     0,     0,    39,   195,    38,   196,    62,     0,    36,
-     193,    37,   194,    60,   391,   392,     0,     0,     0,     0,
-     485,   312,   580,   580,     0,   488,   522,     0,     0,   415,
-     337,     0,    12,   417,     0,   298,     0,   299,     0,     0,
-     309,   262,   594,   246,   348,   345,   532,     0,   383,     0,
-       0,     0,   502,     0,   510,     0,   512,     0,   518,     0,
-     515,   520,     0,     0,     0,   492,     0,   351,   352,   355,
-     363,   537,     0,   366,     0,   368,   388,   265,   401,   231,
-     230,    35,   192,   405,   403,     0,     0,   487,   486,   320,
-       0,     0,   414,     0,    96,   103,     0,   416,     0,   302,
-     305,     0,   407,   408,   406,     0,     0,   343,   381,   582,
-     379,   382,   386,   385,   507,   507,   507,   507,   376,   374,
-     285,     0,   495,   594,     0,   354,   361,   355,   355,   355,
-     539,   355,   355,    56,   315,     0,   102,     0,   594,     0,
-     594,   594,     0,   349,   346,     0,   341,     0,   378,   511,
-       0,   508,   513,   516,   571,   284,   350,     0,   358,     0,
-     360,     0,   367,     0,   364,   369,   323,    99,   101,     0,
-     567,   568,   409,   335,   310,     0,   344,     0,   380,   507,
-     355,   355,   355,   355,    97,   342,   509,   359,     0,   356,
-     362,   365,   355,   357
+       0,     0,     0,     0,   586,   603,   585,     0,   588,   587,
+       0,   412,   410,   306,   431,     0,     0,   401,    65,   304,
+     325,   113,   114,   115,   472,   473,   496,   492,   323,     0,
+     603,     0,     0,     0,   584,   583,    56,     0,   603,   297,
+     338,     0,   337,     0,     0,   603,     0,     0,     0,     0,
+       0,     0,   110,     0,   603,     0,   320,     0,   126,     0,
+       0,   451,   453,     0,     0,   602,   567,     0,   273,   572,
+     267,     0,   270,   261,     0,   269,     0,   262,     0,   589,
+       0,   589,   603,   603,   255,   266,   589,     0,   303,    52,
+       0,     0,     0,     0,     0,     0,    17,   589,   295,    13,
+     590,    77,   291,   294,   298,   596,   246,   595,   596,   248,
+     299,   564,   102,    94,     0,    89,     0,     0,   603,     0,
+     531,   308,   392,   467,     0,     0,   442,   448,   446,   437,
+     458,   469,   435,   444,     0,     0,     7,    21,    22,    23,
+      24,    25,    37,    36,    50,    51,   498,   544,     0,   589,
+     589,     0,     0,   499,     0,   512,   559,   509,     0,   513,
+     497,     0,   523,   545,     0,   526,   553,     0,   528,   557,
+       0,     0,   603,     0,    28,    30,     0,    31,   589,     0,
+      82,    93,    48,    38,    46,     0,   249,   198,    29,     0,
+     285,   214,   222,   227,   228,   229,   224,   226,   236,   237,
+     230,   231,   207,   208,   234,   235,    35,    34,   591,   223,
+     225,   219,   220,   221,   209,   210,   211,   212,   213,   576,
+     581,   577,   582,   406,   265,   404,     0,   576,   578,   577,
+     579,   405,   603,   576,   577,   265,   603,   603,    39,   249,
+     199,    45,   206,    63,    66,     0,     0,     0,   113,   114,
+     117,     0,     0,   603,     0,   589,     0,   289,   603,   603,
+     418,   603,   339,   580,   296,     0,   576,   577,   603,   341,
+     313,   340,   316,   107,   109,     0,   106,   108,     0,     0,
+       0,     0,   272,     0,   319,   568,   570,   569,     0,     0,
+     274,   268,   603,   571,   566,   252,   251,   256,   257,   259,
+     302,   593,    19,     0,    26,   205,    79,    16,   589,   594,
+      95,    87,    99,   101,     0,    98,   100,   591,     0,   460,
+       0,   449,   215,   216,   538,   355,   589,   348,   495,   494,
+     240,   330,     0,   506,   603,   558,   515,   543,   516,   516,
+     516,   550,   516,   538,   516,   242,   331,   383,   381,     0,
+     380,   379,   278,     0,    91,    85,     0,     0,     0,     0,
+       0,   603,     0,     0,     0,     0,   403,    69,   409,     0,
+       0,   402,    67,   398,    62,     0,     0,   603,   326,     0,
+       0,   409,   329,   562,    57,   419,   420,   603,   421,     0,
+     603,   344,     0,     0,   342,     0,     0,   409,     0,     0,
+       0,     0,     0,   105,     0,   127,   456,   318,     0,     0,
+     271,   275,   263,   603,    11,   292,   247,    97,     0,   385,
+       0,     0,   309,   440,   356,   353,   541,     0,     0,   511,
+       0,   519,     0,   521,     0,   527,     0,   524,   529,     0,
+     378,   591,   591,   502,   503,   603,   603,   363,     0,   547,
+     363,   363,   361,     0,     0,   276,    83,    47,   250,   576,
+     577,     0,   576,   577,     0,     0,    44,   203,    43,   204,
+      70,     0,    41,   201,    42,   202,    68,   399,   400,     0,
+       0,     0,     0,   493,   324,     0,     0,   423,   345,     0,
+      12,   425,     0,   310,     0,   311,     0,     0,   321,   274,
+     603,   258,   391,     0,     0,     0,     0,     0,   351,   241,
+     516,   516,   516,   516,   243,     0,     0,     0,   501,     0,
+     359,   360,   363,   371,   546,     0,   374,     0,   376,   396,
+     277,   409,   239,   238,    40,   200,   413,   411,     0,     0,
+       0,   422,     0,   104,   111,     0,   424,     0,   314,   317,
+       0,   415,   416,   414,   389,   591,   387,   390,   394,   393,
+     357,   354,     0,   349,   520,     0,   517,   522,   525,   384,
+     382,   297,     0,   504,   603,     0,   362,   369,   363,   363,
+     363,   548,   363,   363,    64,   327,   110,     0,   603,     0,
+     603,   603,     0,     0,   386,     0,   352,     0,   516,   580,
+     296,   358,     0,   366,     0,   368,     0,   375,     0,   372,
+     377,   107,   109,     0,   576,   577,   417,   343,   322,   388,
+     350,   518,   363,   363,   363,   363,   105,   367,     0,   364,
+     370,   373,   363,   365
 };
 
   /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int16 yypgoto[] =
 {
-    -829,  -829,  -829,   510,  -829,    32,  -829,  -214,   182,  -829,
-      28,  -829,  -155,  -302,   867,     1,   -16,  -829,  -536,  -829,
-     131,   971,  -170,     4,   -69,  -266,  -431,   -15,  1295,   -48,
-     981,    19,     5,  -829,  -829,    24,  -829,   653,  -829,   413,
-      75,   -58,  -352,    54,    13,  -829,  -390,  -235,   -11,    39,
-    -303,    89,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,  -829,
-    -829,  -829,     8,  -206,  -382,     7,  -568,  -829,  -829,  -829,
-     272,   538,  -829,  -512,  -829,  -829,   -78,  -829,     2,  -829,
-    -829,   255,  -829,  -829,  -829,   -65,  -829,  -829,  -430,  -829,
-      14,  -829,  -829,  -829,  -829,  -829,   154,    58,  -196,  -829,
-    -829,  -829,  -829,  -377,  -257,  -829,   787,  -829,  -829,  -829,
-      -6,  -829,  -829,  -829,  1461,  1552,  1026,  1065,  -829,  -829,
-     173,   314,   343,   141,  -829,  -829,  -829,   524,  -306,   246,
-    -307,  -801,  -716,  -519,  -829,   474,  -664,  -627,  -828,   142,
-     346,  -829,   236,  -829,   517,  -439,  -829,  -829,  -829,    92,
-     785,  -411,   505,  -339,  -829,  -829,   -80,  -829,    26,   -22,
-    -152,  -254,   788,   -12,   -33,    -2
+    -870,  -870,  -870,   342,  -870,    37,  -870,   -62,   106,  -870,
+      41,  -870,  -870,  -154,  -352,   896,    85,   132,  -870,    27,
+     192,  -870,  -673,  -870,   -15,    16,  -192,    29,   -72,  -212,
+    -436,    -5,  1770,   -82,   849,    13,     4,  -870,  -870,    24,
+    -870,  1132,  -870,   307,    84,  -224,  -289,   131,    12,  -870,
+    -406,  -229,  -181,    57,  -341,   323,  -870,  -870,  -870,  -870,
+    -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,  -870,
+    -870,  -870,     8,  -215,  -463,  -136,  -624,  -870,  -870,  -870,
+     111,   164,  -870,  -575,  -870,  -870,  -469,  -870,  -133,  -870,
+    -870,    92,  -870,  -870,  -870,   -85,  -870,  -870,  -454,  -870,
+    -129,  -870,  -870,  -870,  -870,  -870,    43,    83,  -165,  -870,
+    -870,  -870,  -870,  -433,  -201,  -870,   641,  -870,  -870,  -870,
+       2,  -870,  -870,  -870,  1740,  2183,   886,  1575,  -870,  -870,
+     421,    66,   287,   320,   -41,  -870,  -870,  -870,   280,   -27,
+     239,  -248,  -816,  -684,  -524,  -870,   228,  -746,  -548,  -869,
+     -38,   326,  -870,  -506,  -870,   273,  -345,  -870,  -870,  -870,
+      51,   647,  -442,   593,  -296,  -870,  -870,   -80,  -870,    55,
+     -12,   274,  -262,   425,   -16,   -34,    -2
 };
 
   /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int16 yydefgoto[] =
 {
-      -1,     1,     2,    66,    67,    68,   278,   413,   414,   287,
-     288,   466,    70,   561,    71,   207,    72,    73,   620,   750,
-      74,    75,   289,    76,    77,    78,   491,    79,   208,   117,
-     118,   234,   235,   236,   656,   598,   201,    81,   294,   565,
-     599,   268,   456,   457,   269,   270,   259,   449,   484,   458,
-     555,    82,   204,   292,   685,   293,   308,   698,   214,   777,
-     215,   778,   655,   941,   623,   621,   859,   407,   409,   632,
-     633,   866,   281,   417,   647,   769,   770,   221,   796,   945,
-     965,   910,   818,   722,   723,   819,   798,   949,   950,   510,
-     802,   346,   550,    84,    85,   395,   613,   612,   440,   944,
-     636,   763,   868,   872,    86,    87,    88,   321,   322,   531,
-      89,    90,    91,   532,   244,   245,   246,   435,    92,    93,
-      94,   315,    95,    96,   210,   211,    99,   212,   403,   622,
-     758,   511,   512,   821,   822,   513,   514,   515,   807,   707,
-     759,   518,   519,   520,   696,   521,   522,   523,   826,   827,
-     524,   525,   526,   527,   528,   701,   203,   408,   299,   459,
-     443,   263,   123,   627,   601,   412,   406,   386,   463,   799,
-     464,   482,   248,   249,   250,   291
+      -1,     1,     2,    66,    67,    68,   284,   457,   458,   293,
+     294,   510,    70,    71,   603,    72,    73,    74,   676,   212,
+      75,    76,   664,   797,    77,    78,   295,    79,    80,    81,
+     535,    82,   213,   122,   123,   240,   241,   242,   699,   642,
+     206,    84,   300,   607,   643,   274,   500,   501,   275,   276,
+     265,   493,   528,   502,   597,    85,   209,   298,   728,   299,
+     314,   738,   220,   821,   221,   822,   698,   970,   667,   665,
+     902,   452,   287,   461,   690,   813,   814,   227,   746,   926,
+     996,   943,   861,   769,   770,   862,   838,   975,   976,   541,
+     842,   389,   592,    87,    88,   439,   657,   656,   484,   973,
+     679,   807,   906,   910,    89,    90,    91,   327,   328,   545,
+      92,    93,    94,   546,   250,   251,   252,   479,    95,    96,
+      97,   321,    98,    99,   216,   217,   102,   218,   448,   666,
+     446,   367,   368,   369,   864,   865,   370,   371,   372,   756,
+     582,   374,   375,   376,   377,   568,   378,   379,   380,   869,
+     870,   381,   382,   383,   384,   385,   575,   208,   453,   305,
+     503,   487,   269,   128,   671,   645,   456,   451,   430,   507,
+     839,   508,   526,   254,   255,   256,   297
 };
 
   /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
@@ -2403,456 +2434,488 @@ static const yytype_int16 yydefgoto[] =
      number is the opposite.  If YYTABLE_NINF, syntax error.  */
 static const yytype_int16 yytable[] =
 {
-     102,   517,   516,   383,   385,   275,   658,   425,   237,   351,
-      83,   213,    83,   120,   120,   276,   243,   209,   209,   271,
-     389,   220,   237,   209,   209,   209,   199,   453,   209,   602,
-      69,   200,    69,   277,   337,   273,   103,   490,   200,   304,
-     600,   247,   485,   671,   608,   649,   487,   611,   333,   566,
-     297,   301,   200,   628,   290,   260,   260,   825,    83,   260,
-     668,   688,   305,   533,   668,   662,   399,   629,   766,   642,
-     258,   264,   209,   671,   265,   314,   705,   776,   652,   885,
-     200,   600,   812,   608,   970,   387,   305,   694,   951,   614,
-     617,   295,   629,   336,   119,   119,   267,   272,  -564,   416,
-     748,   749,   119,   274,   -99,   271,   800,   242,   262,   262,
-     384,  -472,   262,  -101,   394,   473,   324,   326,   328,   330,
-     -96,   209,  -475,    83,   380,   535,   728,   841,   535,   422,
-     535,   629,   535,  -474,   535,  -103,  -476,   477,  -102,  -104,
-     431,   479,   691,   119,   296,   300,   -98,   256,   256,   695,
-     397,   256,  -471,   646,   398,   794,   629,   497,   498,   499,
-     500,  -466,   987,   387,     3,  -100,   382,   119,   242,   970,
-     261,   261,   279,   501,   261,  -466,   393,   424,  -475,   556,
-     -96,   -97,   267,   272,   283,   533,   951,   808,   801,  -474,
-    -477,   842,  -476,   630,   345,   388,   238,   560,   393,   239,
-     240,   470,   697,   516,   847,  -103,   261,   261,  -564,   853,
-    -466,   765,    83,   439,  -564,   426,   427,  -466,  -401,   -91,
-     348,  -567,   209,   209,   453,   495,   490,   241,   -93,   242,
-    -568,   986,   286,   720,   489,   -88,   560,   560,   858,   238,
-     471,   390,   239,   240,   884,   825,  -477,   353,   825,   450,
-     -95,   454,   314,   -94,   476,   -69,   391,   200,   451,  -479,
-     451,   -90,   483,   483,   460,   671,   812,   483,  -102,   436,
-     241,   392,   242,   388,   209,   717,   -83,   721,   209,   266,
-     -92,  -401,   209,   209,   481,   668,   668,    83,   786,   290,
-     347,   490,    83,    83,  -471,  -401,   -89,   286,   833,  -103,
-      83,   266,   506,   672,   376,   377,   378,  -478,  -480,   260,
-     677,   305,   472,   475,   942,  -479,  -466,   352,  -470,   274,
-     478,   683,   -96,   402,   461,   415,   516,   507,  -401,   410,
-    -401,   552,   762,   825,   535,   558,   562,  -401,   423,   543,
-     544,   545,   546,   -88,   419,    83,   209,   209,   209,   209,
-      83,   209,   209,   290,   432,   209,   626,    83,   305,   774,
-     567,   428,   262,  -478,  -480,    69,   892,   775,   808,   542,
-     547,   530,  -466,   -98,  -470,   562,   562,   437,   808,   460,
-     239,   240,   838,   907,   908,   411,   554,   -98,  -328,   209,
-     808,   554,   119,   434,   600,  -100,   608,   256,   880,   567,
-     567,   256,  -328,   460,   727,   717,   439,   606,   533,   753,
-     606,   448,   637,   209,    42,    83,   209,    43,   442,   460,
-     261,   687,   467,   489,   261,    83,   665,   353,   460,   209,
-     606,   392,   792,    83,   788,   843,   276,  -328,   209,   119,
-     849,   851,   -68,    83,  -328,   474,   606,   675,   676,   876,
-     863,   516,   943,   486,   785,   606,   451,   451,   607,  -103,
-     237,   468,    60,   490,   480,   102,   416,   286,   331,   332,
-     -98,   679,   671,   -98,   -98,    83,   488,   -97,   660,   756,
-     -95,   607,   808,   674,    83,   343,   344,   735,   489,   471,
-     200,   379,   460,   668,   606,    69,   808,   607,   305,   742,
-     305,   -98,   209,   -98,   684,   380,   607,   101,   830,   101,
-     492,   702,   256,   702,   101,   101,   540,  -102,   541,   606,
-     101,   101,   101,   743,   996,   101,   619,   -98,   742,   717,
-     848,   286,   559,   791,   856,   261,   256,   634,   -94,    83,
-     381,   635,   669,   726,   864,   607,   921,   382,   724,   639,
-     744,  -100,   256,   746,   788,   101,   -98,   661,   -97,   261,
-     516,   256,   736,   238,   529,   305,   239,   240,   673,   101,
-     607,   744,   276,   686,   678,   261,   560,   -90,  -565,   119,
-     681,   119,   560,   404,   261,   -83,   890,   560,   560,  -582,
-     448,   700,  -582,  -582,   241,  -100,   242,   380,   794,   638,
-     497,   498,   499,   500,   261,   703,   271,   645,   261,   271,
-     724,   724,   704,   740,   730,   420,   501,   657,   101,   706,
-     101,   745,   242,   752,   747,   256,  1009,   271,  -274,   380,
-     209,    83,   405,   764,   767,   261,   767,   709,   261,   382,
-     629,  -470,  -274,   767,   886,   926,   119,   711,   261,   784,
-     237,   712,   760,   483,   743,  -470,   780,   200,   454,   714,
-     489,   781,   936,   209,   421,   400,   401,   451,   938,   257,
-     257,   382,   729,   257,   554,   739,   316,  -274,   317,   318,
-     200,   854,  -100,   267,  -274,   276,   267,   985,  -565,   741,
-    -470,   731,  -100,   560,  -565,  -100,  -100,  -470,   429,   754,
-     280,   282,   739,   -92,   267,   257,   298,   768,   765,   101,
-     927,   928,   380,   716,   755,   562,   975,   334,   335,   101,
-     101,   562,   845,  -100,   765,  -100,   562,   562,   319,   320,
-      83,   948,   460,   497,   498,   499,   500,   305,    83,   567,
-     902,   903,   209,   353,   773,   567,   209,   430,   724,   501,
-     567,   567,   779,   782,   382,   783,    83,    83,   834,   606,
-     790,   869,  -571,   848,   873,   793,    83,   789,   242,   874,
-     710,   101,   713,    83,   816,   101,   209,   861,   883,   101,
-     101,   867,   343,   344,   101,    83,    83,   451,   871,   101,
-     101,   -97,   238,    83,   875,   239,   240,   101,   374,   375,
-     376,   377,   378,   702,   616,   618,   276,   276,    83,    83,
-     607,   534,   -89,   317,   318,   877,   887,   888,   119,   803,
-     702,   702,   889,   694,   893,  -571,   895,   897,   905,   261,
-     261,   899,   562,   911,   906,   909,   616,   618,   912,  -571,
-     502,   914,   101,   101,   101,   101,   101,   101,   101,   101,
-     916,   918,   101,   979,   101,   923,   567,   101,   238,   924,
-     929,   239,   240,   319,   320,   256,    83,    83,   505,   506,
-     939,   940,  -571,   946,  -571,   933,   206,   206,  -567,    83,
-     767,  -571,   206,   952,   682,   469,   101,   493,   261,   241,
-     953,   242,   960,   958,   507,   959,   101,   101,   973,   380,
-     329,   380,  -284,   317,   318,   444,   445,   446,   334,   119,
-     101,   974,   101,   101,   119,  -473,  -284,   976,   990,   257,
-     997,   539,   101,   257,   317,   318,   101,   988,  1006,  -473,
-     101,   857,   999,  1001,   421,   101,   494,   276,    83,  1003,
-     101,   382,   810,   382,    83,   813,    83,   870,  -273,    83,
-    1014,  -284,  1015,   319,   320,  -568,   119,   828,  -284,   878,
-     879,   702,  -273,  1017,  -473,   238,  -567,   882,   239,   240,
-    -568,  -473,   101,  1024,   319,   320,   460,   680,   637,   767,
-     396,   101,  1028,   891,   218,  -567,   209,   124,  1013,  1018,
-     323,   317,   318,   817,  1012,   418,   241,  -273,   242,   101,
-     553,   418,   855,   606,  -273,   564,   569,   570,   571,   572,
-     573,   574,   575,   576,   577,   578,   579,   580,   581,   582,
-     583,   584,   585,   586,   587,   588,   589,   590,   591,   592,
-     593,   594,   438,   202,   257,   820,   101,   261,   441,   930,
-     925,   319,   320,   804,   615,   615,   452,   962,  -567,  -568,
-    -285,   967,   809,   937,   607,   894,   896,   898,   257,   900,
-       0,   901,  -567,     0,  -285,   733,     0,   100,     0,   100,
-     122,   122,   615,     0,   257,     0,   615,   615,   223,   380,
-       0,   206,   206,   257,   961,     0,     0,   325,   317,   318,
-       0,     0,   659,     0,     0,  -567,   663,  -567,   380,  -285,
-     664,  -567,     0,   667,  -567,   670,  -285,   298,     0,   256,
-       0,     0,  -568,     0,   734,   100,     0,   977,   980,   307,
-     981,   382,     0,   982,   615,   441,  -568,   101,   101,   955,
-       0,   380,   261,   405,   667,     0,     0,   298,   319,   320,
-     382,   462,   465,   307,     0,   968,     0,   257,   971,     0,
-     844,   846,     0,     0,     0,   850,   852,     0,     0,  -568,
-     101,  -568,     0,     0,   699,  -568,   978,     0,  -568,     0,
-     797,     0,     0,   382,   794,   708,   497,   498,   499,   500,
-     100,     0,     0,   811,   844,   846,   815,   850,   852,   327,
-     317,   318,   501,   718,   719,   824,     0,     0,     0,     0,
-     989,   991,   992,   993,   725,   206,   206,   206,   206,     0,
-     548,   549,     0,     0,   648,   648,   503,   806,     0,     0,
-     820,   806,   795,   820,   805,     0,   820,   101,   820,   529,
-     317,   318,     0,  1021,     0,   101,   101,     0,   829,   101,
-     319,   320,   101,   101,     0,   823,     0,   101,   101,   536,
-     317,   318,     0,   101,   101,     0,     0,     0,   537,   317,
-     318,   922,     0,   101,   441,  1026,     0,     0,     0,   100,
-     101,   441,     0,   101,     0,   631,     0,     0,   820,     0,
-     319,   320,   101,   101,     0,     0,     0,     0,   761,   922,
-     101,   338,   339,   340,   341,   342,     0,    80,     0,    80,
-     319,   320,     0,     0,     0,   101,   101,     0,   219,   319,
-     320,   820,     0,   820,     0,   820,     0,   820,     0,   787,
-     538,   317,   318,     0,     0,     0,     0,     0,   667,   298,
-       0,     0,     0,   496,     0,   497,   498,   499,   500,     0,
-       0,     0,   820,     0,   100,    80,   715,   317,   318,   100,
-     100,   501,     0,   101,   502,     0,     0,   100,     0,     0,
-       0,     0,     0,   101,   101,   913,   915,   954,   307,   956,
-       0,   319,   320,   957,     0,   503,   101,     0,     0,   832,
-       0,   504,   505,   506,   615,   835,   969,   257,   972,     0,
-     615,   615,     0,     0,     0,   615,   615,   319,   320,     0,
-       0,     0,   100,     0,     0,     0,     0,   100,   507,   751,
-      80,   508,     0,     0,   100,   307,     0,   568,     0,   983,
-     984,     0,   964,   806,   615,   615,   829,   615,   615,   829,
-     963,   829,     0,   823,     0,   101,   823,   881,   823,     0,
-       0,   101,     0,   101,     0,     0,   101,   966,   418,     0,
-       0,     0,     0,     0,     0,     0,   568,   568,     0,  1016,
-       0,     0,     0,    97,  1019,    97,   121,   121,   121,     0,
-       0,  1020,   100,  1022,   222,     0,     0,  1023,     0,     0,
-       0,   829,   100,   101,   917,     0,     0,     0,   823,   206,
-     100,  1025,     0,     0,   919,   920,     0,     0,     0,    80,
-     100,   615,  1032,     0,     0,   998,  1000,  1002,     0,  1004,
-    1005,    97,     0,     0,   829,   306,   829,     0,   829,     0,
-     829,   823,   206,   823,     0,   823,     0,   823,     0,   615,
-       0,     0,   100,     0,   353,     0,   298,     0,     0,   306,
-     860,   100,     0,     0,     0,   829,     0,   865,     0,   366,
-     367,   353,   823,     0,    98,   307,    98,   307,  1027,  1029,
-    1030,  1031,   353,     0,     0,     0,   366,   367,   648,     0,
-    1033,     0,     0,     0,    80,     0,    97,   366,   367,    80,
-      80,   794,     0,   497,   498,   499,   500,    80,   373,   374,
-     375,   376,   377,   378,  -281,     0,   100,  -281,  -281,   501,
-       0,     0,    98,   371,   372,   373,   374,   375,   376,   377,
-     378,     0,     0,     0,     0,     0,     0,   374,   375,   376,
-     377,   378,   307,   503,  -281,  -281,     0,  -281,     0,   947,
-     238,   257,    80,   239,   240,   206,   794,    80,   497,   498,
-     499,   500,     0,     0,    80,     0,     0,   563,   496,     0,
-     497,   498,   499,   500,   501,     0,   418,   448,     0,     0,
-       0,   241,   418,   242,     0,    97,   501,    98,     0,   502,
-       0,     0,     0,     0,     0,     0,     0,     0,   503,     0,
-       0,     0,     0,     0,     0,     0,   563,   563,   100,     0,
-     503,     0,     0,     0,     0,     0,   504,   505,   506,     0,
-       0,   496,    80,   497,   498,   499,   500,     0,     0,     0,
-       0,     0,    80,     0,     0,     0,     0,     0,     0,   501,
-      80,     0,   502,   507,     0,     0,   508,     0,     0,     0,
-      80,     0,     0,     0,     0,     0,     0,     0,     0,   509,
-      97,     0,     0,   503,     0,    97,    97,     0,     0,   504,
-     505,   506,     0,    97,     0,     0,    98,     0,     0,     0,
-       0,     0,    80,     0,   306,     0,     0,     0,     0,     0,
-     496,    80,   497,   498,   499,   500,   507,     0,     0,   508,
-       0,     0,     0,     0,     0,     0,     0,   100,   501,     0,
-       0,   502,   757,     0,   307,   100,   568,     0,    97,     0,
-       0,     0,   568,    97,     0,     0,     0,   568,   568,     0,
-      97,   306,   503,   100,   100,     0,     0,     0,   504,   505,
-     506,     0,     0,   100,     0,     0,    80,     0,     0,     0,
-     100,    98,     0,     0,     0,     0,    98,    98,     0,     0,
-       0,     0,   100,   100,    98,   507,     0,     0,   508,     0,
-     100,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   100,   100,     0,    97,     0,
-       0,     0,     0,     0,     0,     0,     0,   496,    97,   497,
-     498,   499,   500,     0,     0,   122,    97,     0,     0,    98,
-     122,     0,     0,     0,    98,   501,    97,     0,   502,     0,
-       0,    98,     0,     0,    98,     0,     0,     0,     0,     0,
-     862,     0,     0,   568,     0,     0,     0,     0,    80,   503,
-       0,     0,     0,   100,   100,   504,   505,   506,    97,     0,
-       0,     0,   935,     0,     0,     0,   100,    97,     0,     0,
-       0,     0,     0,    98,    98,     0,     0,     0,     0,     0,
-       0,   306,   507,   306,     0,   508,     0,     0,   814,    98,
-     497,   498,   499,   500,     0,     0,     0,     0,     0,    98,
-       0,     0,     0,     0,     0,     0,   501,    98,     0,   502,
-       0,     0,     0,     0,     0,     0,     0,    98,     0,     0,
-       0,     0,    97,     0,     0,   100,     0,     0,     0,     0,
-     503,   100,     0,   100,     0,     0,   100,   505,   506,     0,
-       0,     0,     0,     0,     0,     0,     0,    80,   306,    98,
-       0,     0,     0,     0,     0,    80,   563,     0,    98,     0,
-       0,     0,   563,   507,     0,     0,     0,   563,   563,     0,
-       0,     0,     0,    80,    80,     0,     0,     0,     0,     0,
-       0,     0,     0,    80,     0,     0,     0,     0,     0,     0,
-      80,  -594,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    80,    80,  -594,  -594,  -594,  -594,  -594,  -594,
-      80,  -594,     0,    98,    97,     0,     0,  -594,  -594,     0,
-       0,     0,     0,     0,     0,    80,    80,     0,  -594,  -594,
-       0,  -594,  -594,  -594,  -594,  -594,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     105,   262,   262,   433,   469,   262,   427,   429,   692,   394,
+      86,   282,    86,   125,   125,   281,   243,   215,   215,   277,
+     204,   226,   868,   215,   215,   215,   701,   579,   215,   224,
+     243,   205,   283,   343,   279,   443,   761,   219,   205,   497,
+     529,   106,   249,    69,   531,    69,   373,   373,   431,   310,
+     303,   307,   205,   705,   608,   810,   714,   757,    86,   267,
+     267,   845,   311,   267,   820,   431,   542,   268,   268,   320,
+     253,   268,   215,   266,   266,   759,  1001,   266,   762,   296,
+     205,   795,   796,   658,   661,   494,   714,   498,   711,   311,
+     120,   120,   711,   373,   373,   267,   267,   534,   120,   517,
+     731,   350,   351,   302,   306,   273,   278,   977,   277,   301,
+     840,   566,   350,   351,   890,   689,   438,   570,   884,   896,
+     525,  -480,   342,     3,   215,   547,    86,   644,   767,  -479,
+     809,   652,   483,   434,   655,   466,   646,   121,   121,   120,
+     387,   330,   332,   334,   336,   121,   475,   264,   270,  -112,
+     289,   271,   349,  1001,  1013,   673,   292,  -104,   432,  -483,
+     248,   672,   549,   775,   272,   549,   120,   549,   644,   549,
+     652,   549,   768,   567,   391,   432,   685,   244,   -96,   673,
+     245,   246,   885,   337,   338,   695,   121,   387,   437,  -296,
+     752,   388,   841,  -479,   273,   278,   868,   977,  -482,   868,
+     598,   244,  -296,  -296,   245,   246,   390,   514,   247,   -77,
+     248,   358,   437,   121,   285,  -483,  -296,    86,   673,   444,
+     445,  -104,   901,  -484,   292,   812,   809,  -485,   215,   215,
+     -91,   539,   247,   395,   248,  -487,   272,   533,  -296,   361,
+     362,   602,  -577,   673,   983,  -296,   362,   470,   471,   734,
+     396,  -296,   320,  -101,  -482,  -577,   339,   262,  -296,   520,
+    -486,   262,   871,   205,   495,   363,   495,   527,   527,   280,
+     504,   363,   527,   248,   497,   830,   868,   714,  -488,  -484,
+     215,   602,   602,  -485,   215,   547,  -336,   373,   215,   215,
+    -474,  -487,   737,    86,  -478,   435,   971,   280,    86,    86,
+    -336,  -573,   761,   447,   480,   572,    86,   420,   421,   422,
+     454,   459,   711,   711,   441,   267,  -486,   311,   442,   267,
+     296,   718,   719,   757,   534,   591,   463,   268,   124,   124,
+     757,   516,   436,   266,  -488,  -336,   124,   806,   373,   522,
+     876,   468,  -336,   467,   931,   741,  -474,   472,   519,   428,
+    -478,    86,   215,   215,   215,   215,    86,   226,   215,   215,
+    -111,   918,   476,   424,  -474,   562,   455,   670,   576,  -111,
+     576,   557,   558,   559,   560,    86,   478,   124,  -474,   549,
+     556,  -103,    42,   483,    69,    43,   515,   534,   600,   561,
+     674,   512,   935,   936,   120,    86,   515,   292,   215,   492,
+      86,   311,   544,   609,   124,   426,   486,   505,   511,   849,
+     262,  -573,   436,  -474,  -110,   773,   396,  -573,   757,   226,
+    -474,   296,   518,   504,  -110,   789,   530,   626,   791,   -76,
+      60,   793,   886,   215,   120,   262,   999,   892,   894,  1002,
+    -111,   121,   818,   609,   609,  -102,   532,   596,   504,   791,
+     262,   650,   596,  -106,   650,   524,   680,   790,   215,   262,
+      86,   215,   730,   504,   533,   536,   972,   836,   267,    86,
+    -106,   554,   504,   215,   -98,   650,   282,    86,   120,   714,
+     708,   121,   215,   832,   644,  -108,   652,    86,   829,   555,
+     650,   757,   881,   267,   366,   386,   120,   571,   292,   650,
+     495,   495,   757,   577,   741,   891,  -100,   547,   267,   105,
+     574,   651,   243,   373,   722,   711,  1043,   267,   586,    86,
+     940,   941,   828,   262,   578,   121,   581,   533,    86,   782,
+     819,   498,   914,  -105,   205,   651,   504,   267,   650,   954,
+     703,   267,   311,   121,   311,   712,   215,   584,   587,   590,
+     651,   789,    69,    86,   -97,   589,   717,   663,  -108,   651,
+    -105,   727,   460,   650,   534,   790,   891,   681,   267,   521,
+     677,   267,   601,   523,   678,   688,   729,   423,   682,  -106,
+     543,   267,   594,   396,   704,   700,   716,   604,   721,   -91,
+     771,   424,   724,  -108,  -105,   104,   481,   104,   651,   245,
+     246,   751,   104,   104,   832,   800,   766,   311,   104,   104,
+     104,   244,   282,   104,   245,   246,   783,   460,   776,   120,
+     585,   120,   588,   651,   602,   777,   425,   604,   604,   741,
+     602,  -481,   124,   426,   778,   602,   602,   462,   418,   419,
+     420,   421,   422,   104,   462,  -481,   788,   801,   802,  1021,
+     277,   740,   921,   277,   771,   771,   787,   104,   809,   244,
+     817,   823,   245,   246,   792,   826,   121,   794,   121,   827,
+     834,   277,   124,   837,   215,    86,   808,   811,   248,   811,
+    -481,   485,   -96,   847,   120,   843,   811,  -481,   566,   804,
+     247,   965,   248,   799,   850,   527,   852,   967,   854,   856,
+     205,   243,   904,   825,   533,   905,   215,   873,   897,   104,
+     495,   104,   909,   673,   244,   449,   124,   245,   246,  1033,
+     913,   282,   915,   205,   923,   824,   922,   927,   786,   424,
+     939,   121,  -285,   899,   124,   596,   273,   602,   942,   273,
+     945,   492,   660,   662,   947,   247,  -285,   248,  -409,   949,
+     951,   464,   576,   956,   957,   786,   335,   273,  -409,   323,
+     324,   267,   267,   968,   450,   424,   262,   969,   485,   833,
+     978,   426,   979,   715,   660,   662,   985,    86,   924,   504,
+     720,  -285,   989,  -103,   311,    86,   609,   990,  -285,   215,
+     991,   726,   609,   215,  1004,   771,   747,   609,   609,   580,
+     465,  1005,   104,    86,    86,   907,   650,   426,   911,   325,
+     326,  -409,   760,   104,   104,   764,  1006,    86,   877,  1015,
+     215,  -409,   725,  -591,   267,  -409,  -591,  -591,  1017,    86,
+      86,   495,  1022,  1024,  1026,  -409,  1028,    86,  1046,   912,
+     959,  1038,  -576,   748,   749,   282,   282,   755,    86,    86,
+    -577,   755,  1048,   723,   754,   129,   248,   124,  -409,   124,
+    -409,   120,   -97,   576,   576,   104,   651,  -409,  -409,   104,
+    -409,   938,   774,   104,   104,  1037,   944,  -409,   104,   860,
+    1039,  1036,  1009,   104,   104,   744,   898,   353,   354,   355,
+     356,   104,   482,   207,   753,   691,   691,   553,   993,   609,
+     323,   324,   900,   357,   998,   211,   211,   758,   121,    86,
+      86,   211,  -286,   962,   496,   908,  -297,    86,   811,     0,
+       0,     0,   124,     0,     0,     0,  -286,   916,   917,     0,
+    -297,     0,     0,     0,     0,   920,   104,   104,   104,   104,
+     104,   104,     0,   104,   104,   485,     0,   925,   120,   803,
+     325,   326,   485,   120,     0,   473,     0,     0,     0,   282,
+     104,  -286,     0,  1014,   267,  -297,     0,  -102,  -286,   424,
+     604,     0,  -297,    86,   844,    86,   604,   888,    86,     0,
+     104,   604,   604,   104,     0,   104,     0,     0,   104,     0,
+     120,   513,   576,   262,     0,   121,   867,   851,   853,   855,
+     121,   857,   835,   858,   474,   424,   504,   958,   680,   811,
+       0,   426,   440,     0,     0,   966,   215,     0,   104,  -293,
+     846,     0,  -293,  -293,  -574,   537,     0,     0,   104,   104,
+       0,     0,     0,   650,   946,   948,     0,   121,     0,   424,
+     465,   872,     0,   104,     0,   104,   104,   426,   866,  -293,
+    -293,   267,  -293,   396,   104,   863,     0,     0,   104,  -106,
+       0,   744,   104,   353,   354,   355,   356,   104,   409,   410,
+       0,  1010,   104,  1011,   538,     0,  1012,     0,   930,   357,
+     932,   426,     0,   604,   933,     0,     0,  -478,  -481,     0,
+     798,   887,   889,   651,     0,     0,   893,   895,     0,   124,
+       0,  -478,  -481,  -108,   104,     0,   997,   417,   418,   419,
+     420,   421,   422,   104,     0,     0,   211,   211,     0,     0,
+       0,     0,   887,   889,     0,   893,   895,     0,   462,     0,
+     322,   104,   323,   324,  -574,     0,  -478,  -481,   104,  -285,
+    -574,   214,   214,  -478,  -481,     0,     0,   214,   263,   263,
+     982,     0,   263,  -285,   980,   981,  -106,     0,     0,  -106,
+    -106,     0,  1023,  1025,  1027,     0,  1029,  1030,     0,   984,
+     986,   987,   988,  1000,  -580,  1003,   506,   509,     0,   286,
+     288,     0,   325,   326,   263,   304,   124,  -106,  -285,  -106,
+       0,   124,     0,     0,     0,  -285,   340,   341,   955,     0,
+    -108,     0,     0,  -108,  -108,     0,  1047,  1049,  1050,  1051,
+    1016,     0,   755,  1018,     0,   872,  1053,  -580,   872,   994,
+     872,   955,   866,     0,   903,   866,   863,   866,   124,   863,
+       0,  -108,   863,  -108,   863,  -576,     0,  -580,     0,     0,
+     211,   211,   211,   211,     0,  1040,   564,   565,   214,   691,
+    1042,  -580,  1044,  -576,     0,     0,  1045,  1041,  -297,   104,
+     104,   744,     0,   353,   354,   355,   356,     0,   872,   780,
+       0,     0,  -297,     0,     0,   866,  1052,     0,     0,   357,
+    -580,     0,   863,   424,  -580,     0,  -580,  -577,   -99,     0,
+    -576,   104,     0,  -580,  -580,   872,     0,   872,  -576,   872,
+       0,   872,   866,   359,   866,     0,   866,  -297,   866,   863,
+     992,   863,  -576,   863,  -297,   863,  -576,     0,   781,     0,
+       0,   872,     0,     0,   424,   426,     0,  -580,   866,  -580,
+    -576,   462,  -577,  -576,     0,   863,  -580,   462,   974,     0,
+     353,   354,   355,   356,     0,  -576,     0,  -576,     0,   675,
+    -577,  -576,   214,   214,  -576,     0,   357,     0,     0,   450,
+       0,  1007,   104,  -576,  -577,  -576,   426,   -98,     0,  -576,
+     104,   104,  -576,     0,   104,   424,     0,   104,   104,   329,
+     323,   324,   104,   104,   548,     0,   323,   324,   104,   104,
+     488,   489,   490,   340,     0,  -577,     0,  -577,     0,  -577,
+       0,  -100,   104,  -577,   263,   104,  -577,     0,   263,  -577,
+    1008,     0,   214,   214,   104,   104,     0,   426,     0,     0,
+       0,     0,   104,   331,   323,   324,     0,     0,     0,     0,
+     325,   326,     0,   104,   104,     0,   325,   326,     0,   333,
+     323,   324,  -577,     0,  -577,   543,   323,   324,  -577,   396,
+       0,  -577,     0,     0,   244,     0,     0,   245,   246,     0,
+       0,   550,   323,   324,   409,   410,     0,     0,   763,     0,
+     353,   354,   355,   356,   325,   326,   214,   214,   214,   214,
+       0,   492,   214,   214,   104,   247,   357,   248,     0,   358,
+     325,   326,     0,     0,   104,   104,   325,   326,     0,     0,
+     573,     0,   104,     0,   418,   419,   420,   421,   422,     0,
+     359,   583,   325,   326,   551,   323,   324,   361,   362,     0,
+       0,     0,   595,   552,   323,   324,     0,   606,   611,   612,
+     613,   614,   615,   616,   617,   618,   619,   620,   621,   622,
+     623,   624,   625,   363,   628,   629,   630,   631,   632,   633,
+     634,   635,   636,   637,   638,   396,     0,   263,   104,     0,
+     104,     0,   211,   104,     0,   325,   326,   659,   659,     0,
+     409,   410,     0,     0,   325,   326,     0,   103,     0,   103,
+     127,   127,   263,     0,     0,   214,     0,   244,   229,     0,
+     245,   246,     0,     0,   211,   659,     0,   263,     0,   659,
+     659,   104,   739,   323,   324,     0,   263,   415,   416,   417,
+     418,   419,   420,   421,   422,   702,     0,     0,   247,   706,
+     248,     0,     0,   707,  -603,   103,   710,     0,   713,   313,
+     304,   352,     0,   353,   354,   355,   356,  -603,  -603,  -603,
+    -603,  -603,  -603,     0,  -603,     0,     0,   659,     0,   357,
+    -603,  -603,   358,   325,   326,     0,   313,   710,     0,     0,
+     304,  -603,  -603,     0,  -603,  -603,  -603,  -603,  -603,     0,
+     263,     0,     0,   359,   344,   345,   346,   347,   348,   360,
+     361,   362,     0,     0,     0,     0,   742,   743,     0,     0,
+       0,     0,     0,   103,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   750,     0,     0,   363,     0,   211,   364,
+       0,     0,     0,  -603,   352,     0,   353,   354,   355,   356,
+     995,     0,   765,     0,     0,   772,     0,  -603,     0,     0,
+       0,     0,   357,     0,     0,   358,     0,  -603,     0,     0,
+    -603,  -603,   100,     0,   100,   126,   126,   126,     0,     0,
+       0,     0,     0,   228,     0,     0,   359,     0,     0,     0,
+    -603,  -603,   360,   361,   362,     0,   272,  -603,  -603,  -603,
+    -603,     0,    83,     0,    83,   744,     0,   353,   354,   355,
+     356,     0,     0,   225,   103,     0,     0,     0,     0,   363,
+     100,     0,   364,   357,   312,     0,     0,   744,   214,   353,
+     354,   355,   356,     0,     0,   365,     0,     0,     0,     0,
+     805,     0,     0,     0,     0,   357,     0,   359,     0,     0,
+      83,   312,   352,   745,   353,   354,   355,   356,     0,     0,
+     214,     0,     0,     0,     0,     0,     0,     0,     0,   359,
+     357,   831,     0,   358,     0,   928,     0,     0,     0,     0,
+     710,   304,     0,     0,     0,   639,   640,     0,   100,   641,
+     103,     0,     0,     0,   359,   103,   103,     0,     0,     0,
+     360,   361,   362,   103,   173,   174,   175,   176,   177,   178,
+     179,   180,   181,     0,   313,   182,   183,     0,    83,   184,
+     185,   186,   187,     0,     0,     0,     0,   363,     0,     0,
+     364,     0,     0,   188,   189,   875,     0,     0,     0,     0,
+     659,   878,     0,   263,     0,     0,   659,   659,   103,     0,
+       0,   659,   659,   103,   229,     0,   190,   191,   192,   193,
+     194,   195,   196,   197,   198,   199,     0,   200,   201,     0,
+       0,     0,   103,     0,   214,   202,   272,   659,   659,   100,
+     659,   659,     0,     0,   352,     0,   353,   354,   355,   356,
+     919,     0,   103,     0,     0,     0,     0,   103,   313,     0,
+     610,     0,   357,     0,     0,   358,     0,     0,     0,    83,
+     929,     0,     0,     0,     0,     0,   229,     0,     0,     0,
+       0,   934,     0,     0,     0,     0,   359,     0,     0,     0,
+       0,     0,   360,   361,   362,     0,   950,     0,     0,     0,
+     610,   610,     0,     0,     0,     0,   952,   953,     0,     0,
+       0,     0,     0,   659,     0,   100,     0,   103,     0,   363,
+     100,   100,   364,     0,     0,     0,   103,     0,   100,     0,
+       0,     0,     0,     0,   103,   540,   659,     0,     0,   312,
+       0,     0,     0,   304,   103,    83,     0,     0,     0,     0,
+      83,    83,     0,     0,     0,     0,     0,     0,    83,     0,
+       0,     0,     0,     0,     0,   352,     0,   353,   354,   355,
+     356,     0,     0,   100,     0,     0,   103,     0,   100,   228,
+       0,     0,     0,   357,     0,   103,   358,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   100,   569,   313,
+       0,   313,     0,    83,     0,     0,     0,   359,    83,   563,
+     103,     0,     0,   360,   361,   362,     0,   100,     0,     0,
+       0,     0,   100,   312,     0,     0,     0,    83,     0,     0,
+     263,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     363,   228,     0,   364,     0,     0,     0,    83,     0,     0,
+       0,     0,    83,     0,     0,   605,     0,     0,     0,     0,
+       0,     0,     0,     0,   313,     0,     0,     0,     0,     0,
+       0,   627,     0,     0,     0,   101,     0,   101,     0,     0,
+       0,     0,   100,     0,     0,     0,     0,     0,     0,     0,
+       0,   100,     0,     0,     0,   605,   605,     0,     0,   100,
+       0,   396,   397,   398,   399,   400,   401,   402,   403,   100,
+     405,   406,    83,     0,     0,     0,   409,   410,     0,     0,
+       0,    83,     0,   101,     0,     0,     0,     0,     0,    83,
+       0,     0,   103,     0,     0,     0,     0,     0,     0,    83,
+       0,   100,     0,     0,     0,     0,     0,     0,     0,     0,
+     100,   413,   414,   415,   416,   417,   418,   419,   420,   421,
+     422,     0,     0,     0,   312,     0,   312,     0,     0,     0,
+       0,    83,     0,     0,     0,   100,     0,     0,     0,     0,
+      83,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   101,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    83,     0,     0,     0,     0,
+       0,     0,   396,   397,   398,   399,   400,   401,   402,   403,
+     404,   405,   406,  -604,  -604,     0,     0,   409,   410,   312,
+       0,     0,     0,     0,   103,     0,     0,     0,     0,     0,
+       0,   313,   103,   610,     0,     0,     0,     0,     0,   610,
+       0,     0,     0,     0,   610,   610,     0,     0,     0,     0,
+     103,   103,   413,   414,   415,   416,   417,   418,   419,   420,
+     421,   422,     0,     0,   103,     0,     0,     0,     0,     0,
+       0,     0,   101,     0,     0,     0,   103,   103,     0,     0,
+       0,     0,     0,     0,   103,     0,     0,   100,     0,     0,
+       0,     0,     0,     0,     0,   103,   103,   779,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   563,     0,     0,     0,     0,     0,     0,
-    -594,     0,     0,    80,    80,     0,     0,     0,     0,     0,
-       0,     0,   932,     0,  -594,     0,    80,     0,     0,     0,
-       0,     0,     0,     0,  -594,    98,     0,  -594,  -594,     0,
-       0,     0,     0,    97,     0,     0,     0,     0,     0,     0,
-     306,    97,     0,     0,     0,     0,     0,  -594,  -594,     0,
-       0,     0,     0,   266,  -594,  -594,  -594,  -594,     0,    97,
-      97,     0,     0,     0,     0,     0,     0,     0,     0,    97,
-       0,     0,     0,     0,     0,    80,    97,     0,     0,     0,
-       0,    80,     0,    80,     0,     0,    80,     0,    97,    97,
-       0,     0,     0,     0,     0,     0,    97,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    83,   127,     0,
+       0,     0,     0,   127,     0,   396,   397,   398,   399,   400,
+     401,   402,   403,   404,   405,   406,   407,   408,     0,     0,
+     409,   410,     0,     0,     0,     0,   610,     0,   101,     0,
+       0,     0,     0,   101,   101,     0,   103,   103,     0,     0,
+     964,   101,     0,     0,   103,     0,     0,     0,     0,     0,
+       0,     0,     0,   412,     0,   413,   414,   415,   416,   417,
+     418,   419,   420,   421,   422,     0,     0,     0,     0,   100,
+       0,     0,     0,  -272,     0,     0,   312,   100,     0,     0,
+       0,     0,     0,     0,     0,     0,   101,     0,     0,     0,
+       0,   101,     0,     0,     0,   100,   100,     0,     0,    83,
+     103,     0,   103,     0,     0,   103,     0,    83,   605,   100,
+     101,     0,     0,     0,   605,     0,     0,     0,     0,   605,
+     605,   100,   100,     0,     0,    83,    83,     0,     0,   100,
+     101,     0,     0,     0,     0,   101,     0,     0,   101,    83,
+     100,   100,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    83,    83,     0,     0,     0,     0,     0,     0,    83,
+       0,     0,     0,   126,     0,     0,     0,     0,   126,     0,
+      83,    83,     0,     0,     0,     0,     0,     0,   101,   101,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    97,    97,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    98,     0,     0,     0,     0,     0,
-       0,   121,    98,    98,     0,     0,   121,     0,     0,    98,
-       0,     0,     0,     0,    98,    98,     0,     0,     0,     0,
-      98,    98,     0,     0,     0,     0,     0,     0,     0,     0,
-      98,     0,     0,     0,     0,     0,     0,    98,     0,    97,
-      97,     0,     0,     0,     0,     0,     0,     0,   934,    98,
-      98,     0,    97,     0,     0,     0,     0,    98,     0,     0,
-       0,     0,     0,     0,     0,     0,   732,     0,     0,     0,
-       0,     0,    98,    98,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   101,     0,     0,     0,     0,
+       0,   100,   100,     0,   101,   963,     0,     0,     0,   100,
+       0,     0,   101,     0,     0,     0,     0,     0,     0,     0,
+       0,   605,   101,     0,     0,     0,     0,     0,     0,     0,
+       0,    83,    83,     0,     0,   961,     0,     0,     0,    83,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   353,   354,   355,   356,   357,   358,
-     359,   360,   361,   362,   363,   364,   365,     0,     0,   366,
-     367,    97,     0,     0,     0,     0,     0,    97,     0,    97,
-      98,     0,    97,   353,  -595,  -595,  -595,  -595,   358,   359,
-      98,    98,  -595,  -595,     0,     0,     0,     0,   366,   367,
-       0,     0,   368,    98,   369,   370,   371,   372,   373,   374,
-     375,   376,   377,   378,     0,     0,     0,     0,     0,     0,
-       0,     0,  -260,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   101,     0,     0,     0,     0,     0,
+       0,     0,     0,   101,     0,   100,     0,   100,     0,     0,
+     100,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   101,     0,
+       0,     0,     0,     0,     0,    83,     0,    83,     0,     0,
+      83,     0,     0,     0,     0,     0,     0,  -603,     4,     0,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+       0,     0,     0,     0,     0,     0,    15,     0,    16,    17,
+      18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
+      23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
+       0,     0,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,     0,    40,    41,    42,     0,     0,
+      43,     0,     0,    44,    45,     0,    46,    47,    48,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    98,     0,     0,     0,     0,     0,    98,     0,
-      98,  -594,     4,    98,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,     0,     0,     0,     0,     0,     0,
-      15,     0,    16,    17,    18,    19,     0,     0,     0,     0,
-       0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
-      27,     0,     0,     0,     0,     0,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    37,    38,    39,     0,    40,
-      41,    42,     0,     0,    43,     0,     0,    44,    45,     0,
-      46,    47,    48,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    49,     0,     0,
+      50,    51,     0,    52,    53,     0,    54,     0,     0,    55,
+     101,    56,    57,    58,    59,    60,    61,     0,     0,    62,
+    -603,     0,     0,  -603,  -603,     0,     0,   396,  -604,  -604,
+    -604,  -604,   401,   402,     0,     0,  -604,  -604,     0,    63,
+      64,    65,   409,   410,     0,     0,     0,     0,     0,     0,
+       0,  -603,     0,  -603,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   779,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   413,   414,   415,
+     416,   417,   418,   419,   420,   421,   422,     0,     0,     0,
+       0,     0,   396,   397,   398,   399,   400,   401,   402,   403,
+     404,   405,   406,   407,   408,     0,     0,   409,   410,     0,
+       0,     0,   101,     0,     0,     0,     0,     0,     0,     0,
+     101,   101,     0,     0,     0,     0,     0,   101,     0,     0,
+       0,     0,   101,   101,     0,     0,     0,     0,   101,   101,
+     412,     0,   413,   414,   415,   416,   417,   418,   419,   420,
+     421,   422,   101,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   101,   101,     0,     0,     0,     0,
+       0,     0,   101,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   101,   101,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,  -474,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    49,     0,     0,    50,    51,     0,    52,    53,     0,
-      54,     0,     0,    55,     0,    56,    57,    58,    59,    60,
-      61,  -466,     0,    62,  -594,     0,     0,  -594,  -594,     0,
-       0,     0,     0,     0,  -466,  -466,  -466,  -466,  -466,  -466,
-       0,  -466,     0,    63,    64,    65,     0,     0,  -466,  -466,
-       0,     0,     0,     0,     0,  -594,     0,  -594,  -466,  -466,
-       0,  -466,  -466,  -466,  -466,  -466,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   442,     0,
+       0,  -474,  -474,  -474,  -474,  -474,  -474,     0,  -474,     0,
+       0,     0,     0,     0,     0,  -474,  -474,     0,     0,     0,
+       0,     0,     0,     0,   101,  -474,  -474,     0,  -474,  -474,
+    -474,  -474,  -474,     0,   101,   101,     0,     0,     0,     0,
+       0,     0,   101,     0,     0,   486,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,  -466,  -466,  -466,     0,     0,  -466,  -466,
-    -466,     0,  -466,  -466,     0,     0,     0,     0,     0,  -466,
-       0,     0,     0,     0,  -466,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  -466,     0,     0,  -466,  -466,     0,
-    -466,  -466,     0,  -466,  -466,  -466,  -466,  -466,  -466,  -466,
-    -466,  -466,  -466,     0,     0,  -594,     0,     0,  -466,  -466,
-    -466,  -466,     0,     0,  -466,  -466,  -466,  -466,  -594,  -594,
-    -594,  -594,  -594,  -594,     0,  -594,     0,     0,     0,     0,
-       0,     0,  -594,  -594,     0,     0,     0,     0,     0,     0,
-       0,     0,  -594,  -594,     0,  -594,  -594,  -594,  -594,  -594,
+    -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,
+    -474,  -474,  -474,     0,     0,  -474,  -474,  -474,     0,  -474,
+    -474,     0,     0,     0,     0,     0,  -474,     0,     0,     0,
+       0,  -474,     0,     0,     0,     0,     0,     0,   101,     0,
+     101,  -474,     0,   101,  -474,  -474,     0,  -474,  -474,     0,
+    -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,  -474,
+       0,     0,  -603,     0,     0,  -474,  -474,  -474,  -474,     0,
+       0,  -474,  -474,  -474,  -474,  -603,  -603,  -603,  -603,  -603,
+    -603,     0,  -603,     0,     0,     0,     0,     0,     0,  -603,
+    -603,     0,     0,     0,     0,     0,     0,     0,     0,  -603,
+    -603,     0,  -603,  -603,  -603,  -603,  -603,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,  -594,  -594,  -594,
-    -594,  -594,  -594,  -594,  -594,  -594,  -594,  -594,  -594,  -594,
-       0,     0,  -594,  -594,  -594,     0,     0,  -594,     0,     0,
-       0,     0,     0,  -594,     0,     0,     0,     0,  -594,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  -594,     0,
-       0,  -594,  -594,     0,     0,  -594,     0,  -594,  -594,  -594,
-    -594,  -594,  -594,  -594,  -594,  -594,  -594,     0,     0,  -571,
-       0,     0,  -594,  -594,  -594,  -594,     0,   266,  -594,  -594,
-    -594,  -594,  -571,  -571,  -571,     0,  -571,  -571,     0,  -571,
-       0,     0,     0,     0,     0,  -571,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  -571,  -571,     0,  -571,
-    -571,  -571,  -571,  -571,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  -603,  -603,  -603,  -603,  -603,     0,     0,  -603,
+    -603,  -603,     0,     0,  -603,     0,     0,     0,     0,     0,
+    -603,     0,     0,     0,     0,  -603,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,  -603,     0,     0,  -603,  -603,
+       0,     0,  -603,     0,  -603,  -603,  -603,  -603,  -603,  -603,
+    -603,  -603,  -603,  -603,     0,     0,  -580,     0,     0,  -603,
+    -603,  -603,  -603,     0,   272,  -603,  -603,  -603,  -603,  -580,
+    -580,  -580,     0,  -580,  -580,     0,  -580,     0,     0,     0,
+       0,     0,  -580,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,  -580,  -580,     0,  -580,  -580,  -580,  -580,
+    -580,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,  -580,  -580,
+    -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,
+    -580,     0,     0,  -580,  -580,  -580,     0,   784,  -580,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,  -580,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,  -580,
+       0,     0,  -580,  -580,     0,  -107,  -580,     0,  -580,  -580,
+    -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,     0,     0,
+    -580,     0,  -580,  -580,  -580,     0,   -99,     0,     0,  -580,
+    -580,  -580,  -580,  -580,  -580,  -580,     0,  -580,  -580,     0,
+    -580,     0,     0,     0,     0,     0,  -580,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,  -580,  -580,     0,
+    -580,  -580,  -580,  -580,  -580,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  -571,  -571,  -571,  -571,  -571,  -571,  -571,  -571,  -571,
-    -571,  -571,  -571,  -571,     0,     0,  -571,  -571,  -571,     0,
-     737,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  -571,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  -571,     0,     0,  -571,  -571,     0,   -99,  -571,
-       0,  -571,  -571,  -571,  -571,  -571,  -571,  -571,  -571,  -571,
-    -571,     0,     0,  -571,     0,  -571,  -571,  -571,     0,   -91,
-       0,     0,  -571,  -571,  -571,  -571,  -571,  -571,  -571,     0,
-    -571,  -571,     0,  -571,     0,     0,     0,     0,     0,  -571,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    -571,  -571,     0,  -571,  -571,  -571,  -571,  -571,     0,     0,
+       0,     0,  -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,
+    -580,  -580,  -580,  -580,  -580,     0,     0,  -580,  -580,  -580,
+       0,   784,  -580,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,  -580,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,  -580,     0,     0,  -580,  -580,     0,  -107,
+    -580,     0,  -580,  -580,  -580,  -580,  -580,  -580,  -580,  -580,
+    -580,  -580,     0,     0,  -296,     0,  -580,  -580,  -580,     0,
+    -580,     0,     0,  -580,  -580,  -580,  -580,  -296,  -296,  -296,
+       0,  -296,  -296,     0,  -296,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,  -296,  -296,     0,  -296,  -296,  -296,  -296,  -296,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  -571,  -571,  -571,  -571,  -571,
-    -571,  -571,  -571,  -571,  -571,  -571,  -571,  -571,     0,     0,
-    -571,  -571,  -571,     0,   737,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  -571,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  -571,     0,     0,  -571,
-    -571,     0,   -99,  -571,     0,  -571,  -571,  -571,  -571,  -571,
-    -571,  -571,  -571,  -571,  -571,     0,     0,  -284,     0,  -571,
-    -571,  -571,     0,  -571,     0,     0,  -571,  -571,  -571,  -571,
-    -284,  -284,  -284,     0,  -284,  -284,     0,  -284,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  -284,  -284,     0,  -284,  -284,  -284,
-    -284,  -284,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,  -296,  -296,  -296,  -296,
+    -296,  -296,  -296,  -296,  -296,  -296,  -296,  -296,  -296,     0,
+       0,  -296,  -296,  -296,     0,   785,  -296,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,  -296,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,  -296,     0,     0,
+    -296,  -296,     0,  -109,  -296,     0,  -296,  -296,  -296,  -296,
+    -296,  -296,  -296,  -296,  -296,  -296,     0,     0,  -296,     0,
+       0,  -296,  -296,     0,  -101,     0,     0,  -296,  -296,  -296,
+    -296,  -296,  -296,  -296,     0,  -296,  -296,     0,  -296,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  -284,
-    -284,  -284,  -284,  -284,  -284,  -284,  -284,  -284,  -284,  -284,
-    -284,  -284,     0,     0,  -284,  -284,  -284,     0,   738,     0,
+       0,     0,     0,     0,     0,  -296,  -296,     0,  -296,  -296,
+    -296,  -296,  -296,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    -284,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    -284,     0,     0,  -284,  -284,     0,  -101,  -284,     0,  -284,
-    -284,  -284,  -284,  -284,  -284,  -284,  -284,  -284,  -284,     0,
-       0,  -284,     0,     0,  -284,  -284,     0,   -93,     0,     0,
-    -284,  -284,  -284,  -284,  -284,  -284,  -284,     0,  -284,  -284,
-       0,  -284,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,  -284,  -284,
-       0,  -284,  -284,  -284,  -284,  -284,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    -296,  -296,  -296,  -296,  -296,  -296,  -296,  -296,  -296,  -296,
+    -296,  -296,  -296,     0,     0,  -296,  -296,  -296,     0,   785,
+    -296,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,  -296,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,  -296,     0,     0,  -296,  -296,     0,  -109,  -296,     0,
+    -296,  -296,  -296,  -296,  -296,  -296,  -296,  -296,  -296,  -296,
+       0,     0,     0,     0,     0,  -296,  -296,     0,  -296,     0,
+       0,  -296,  -296,  -296,  -296,   290,     0,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,  -603,  -603,  -603,
+       0,     0,  -603,    15,     0,    16,    17,    18,    19,     0,
+       0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
+      26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
+       0,    30,    31,    32,    33,    34,    35,    36,    37,    38,
+      39,     0,    40,    41,    42,     0,     0,    43,     0,     0,
+      44,    45,     0,    46,    47,    48,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  -284,  -284,  -284,  -284,  -284,  -284,  -284,
-    -284,  -284,  -284,  -284,  -284,  -284,     0,     0,  -284,  -284,
-    -284,     0,   738,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  -284,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  -284,     0,     0,  -284,  -284,     0,
-    -101,  -284,     0,  -284,  -284,  -284,  -284,  -284,  -284,  -284,
-    -284,  -284,  -284,     0,     0,     0,     0,     0,  -284,  -284,
-       0,  -284,     0,     0,  -284,  -284,  -284,  -284,   284,     0,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-    -594,  -594,  -594,     0,     0,  -594,    15,     0,    16,    17,
-      18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
-      23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
-       0,     0,    28,     0,    30,    31,    32,    33,    34,    35,
-      36,    37,    38,    39,     0,    40,    41,    42,     0,     0,
-      43,     0,     0,    44,    45,     0,    46,    47,    48,     0,
+       0,     0,     0,     0,    49,     0,     0,    50,    51,     0,
+      52,    53,     0,    54,     0,     0,    55,     0,    56,    57,
+      58,    59,    60,    61,     0,     0,    62,  -603,     0,     0,
+    -603,  -603,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    63,    64,    65,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,  -603,   290,
+    -603,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,     0,     0,  -603,     0,  -603,  -603,    15,     0,    16,
+      17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
+      22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
+       0,     0,     0,    28,     0,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,     0,    40,    41,    42,     0,
+       0,    43,     0,     0,    44,    45,     0,    46,    47,    48,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    49,     0,     0,
-      50,    51,     0,    52,    53,     0,    54,     0,     0,    55,
-       0,    56,    57,    58,    59,    60,    61,     0,     0,    62,
-    -594,     0,     0,  -594,  -594,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    63,
-      64,    65,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,  -594,   284,  -594,     5,     6,     7,     8,     9,    10,
-      11,    12,    13,    14,     0,     0,  -594,     0,  -594,  -594,
-      15,     0,    16,    17,    18,    19,     0,     0,     0,     0,
-       0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
-      27,     0,     0,     0,     0,     0,    28,     0,    30,    31,
-      32,    33,    34,    35,    36,    37,    38,    39,     0,    40,
-      41,    42,     0,     0,    43,     0,     0,    44,    45,     0,
-      46,    47,    48,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    49,     0,
+       0,    50,    51,     0,    52,    53,     0,    54,     0,     0,
+      55,     0,    56,    57,    58,    59,    60,    61,     0,     0,
+      62,  -603,     0,     0,  -603,  -603,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    49,     0,     0,    50,    51,     0,    52,    53,     0,
-      54,     0,     0,    55,     0,    56,    57,    58,    59,    60,
-      61,     0,     0,    62,  -594,     0,     0,  -594,  -594,     0,
+      63,    64,    65,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,  -603,   290,  -603,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,     0,     0,  -603,     0,     0,
+    -603,    15,  -603,    16,    17,    18,    19,     0,     0,     0,
+       0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
+       0,    27,     0,     0,     0,     0,     0,    28,     0,    30,
+      31,    32,    33,    34,    35,    36,    37,    38,    39,     0,
+      40,    41,    42,     0,     0,    43,     0,     0,    44,    45,
+       0,    46,    47,    48,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    63,    64,    65,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,  -594,   284,  -594,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,     0,     0,
-    -594,     0,     0,  -594,    15,  -594,    16,    17,    18,    19,
-       0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
-      25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
-      28,     0,    30,    31,    32,    33,    34,    35,    36,    37,
-      38,    39,     0,    40,    41,    42,     0,     0,    43,     0,
-       0,    44,    45,     0,    46,    47,    48,     0,     0,     0,
+       0,     0,    49,     0,     0,    50,    51,     0,    52,    53,
+       0,    54,     0,     0,    55,     0,    56,    57,    58,    59,
+      60,    61,     0,     0,    62,  -603,     0,     0,  -603,  -603,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    49,     0,     0,    50,    51,
-       0,    52,    53,     0,    54,     0,     0,    55,     0,    56,
-      57,    58,    59,    60,    61,     0,     0,    62,  -594,     0,
-       0,  -594,  -594,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,    63,    64,    65,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,  -594,
-     284,  -594,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,     0,     0,  -594,     0,     0,  -594,    15,     0,
-      16,    17,    18,    19,     0,     0,     0,     0,     0,    20,
-      21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
-       0,     0,     0,     0,    28,     0,    30,    31,    32,    33,
-      34,    35,    36,    37,    38,    39,     0,    40,    41,    42,
-       0,     0,    43,     0,     0,    44,    45,     0,    46,    47,
-      48,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,    49,
-       0,     0,    50,    51,     0,    52,    53,     0,    54,     0,
-       0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
-       0,    62,  -594,     0,     0,  -594,  -594,     4,     0,     5,
+       0,     0,     0,     0,    63,    64,    65,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,  -603,   290,  -603,     5,
        6,     7,     8,     9,    10,    11,    12,    13,    14,     0,
-       0,    63,    64,    65,     0,    15,     0,    16,    17,    18,
-      19,     0,     0,  -594,     0,  -594,    20,    21,    22,    23,
+       0,  -603,     0,     0,  -603,    15,     0,    16,    17,    18,
+      19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
-       0,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+       0,    28,     0,    30,    31,    32,    33,    34,    35,    36,
       37,    38,    39,     0,    40,    41,    42,     0,     0,    43,
        0,     0,    44,    45,     0,    46,    47,    48,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,    49,     0,     0,    50,
       51,     0,    52,    53,     0,    54,     0,     0,    55,     0,
-      56,    57,    58,    59,    60,    61,     0,     0,    62,  -594,
-       0,     0,  -594,  -594,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    63,    64,
-      65,     0,     0,  -594,     0,     0,     0,     0,     0,     0,
-    -594,   284,  -594,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,    14,     0,  -594,  -594,     0,     0,     0,    15,
-       0,    16,    17,    18,    19,     0,     0,     0,     0,     0,
-      20,    21,    22,    23,    24,    25,    26,     0,     0,    27,
-       0,     0,     0,     0,     0,    28,     0,    30,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,     0,    40,    41,
-      42,     0,     0,    43,     0,     0,    44,    45,     0,    46,
-      47,    48,     0,     0,     0,     0,     0,     0,     0,     0,
+      56,    57,    58,    59,    60,    61,     0,     0,    62,  -603,
+       0,     0,  -603,  -603,     4,     0,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,    14,     0,     0,    63,    64,
+      65,     0,    15,     0,    16,    17,    18,    19,     0,     0,
+    -603,     0,  -603,    20,    21,    22,    23,    24,    25,    26,
+       0,     0,    27,     0,     0,     0,     0,     0,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+       0,    40,    41,    42,     0,     0,    43,     0,     0,    44,
+      45,     0,    46,    47,    48,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      49,     0,     0,    50,    51,     0,    52,    53,     0,    54,
-       0,     0,    55,     0,    56,    57,    58,    59,    60,    61,
-       0,     0,    62,  -594,     0,     0,  -594,  -594,   284,     0,
+       0,     0,     0,    49,     0,     0,    50,    51,     0,    52,
+      53,     0,    54,     0,     0,    55,     0,    56,    57,    58,
+      59,    60,    61,     0,     0,    62,  -603,     0,     0,  -603,
+    -603,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    63,    64,    65,     0,     0,
+    -603,     0,     0,     0,     0,     0,     0,  -603,   290,  -603,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-       0,     0,    63,    64,    65,     0,    15,     0,    16,    17,
-      18,    19,     0,     0,  -594,     0,  -594,    20,    21,    22,
+       0,  -603,  -603,     0,     0,     0,    15,     0,    16,    17,
+      18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
       23,    24,    25,    26,     0,     0,    27,     0,     0,     0,
        0,     0,    28,     0,    30,    31,    32,    33,    34,    35,
       36,    37,    38,    39,     0,    40,    41,    42,     0,     0,
       43,     0,     0,    44,    45,     0,    46,    47,    48,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,    49,     0,     0,
-     285,    51,     0,    52,    53,     0,    54,     0,     0,    55,
+      50,    51,     0,    52,    53,     0,    54,     0,     0,    55,
        0,    56,    57,    58,    59,    60,    61,     0,     0,    62,
-    -594,     0,     0,  -594,  -594,   284,     0,     5,     6,     7,
+    -603,     0,     0,  -603,  -603,   290,     0,     5,     6,     7,
        8,     9,    10,    11,    12,    13,    14,     0,     0,    63,
       64,    65,     0,    15,     0,    16,    17,    18,    19,     0,
-    -594,  -594,     0,  -594,    20,    21,    22,    23,    24,    25,
+       0,  -603,     0,  -603,    20,    21,    22,    23,    24,    25,
       26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
        0,    30,    31,    32,    33,    34,    35,    36,    37,    38,
       39,     0,    40,    41,    42,     0,     0,    43,     0,     0,
       44,    45,     0,    46,    47,    48,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    49,     0,     0,    50,    51,     0,
+       0,     0,     0,     0,    49,     0,     0,   291,    51,     0,
       52,    53,     0,    54,     0,     0,    55,     0,    56,    57,
-      58,    59,    60,    61,     0,     0,    62,  -594,     0,     0,
-    -594,  -594,   284,     0,     5,     6,     7,     8,     9,    10,
+      58,    59,    60,    61,     0,     0,    62,  -603,     0,     0,
+    -603,  -603,   290,     0,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,     0,     0,    63,    64,    65,     0,
-      15,     0,    16,    17,    18,    19,     0,  -594,  -594,     0,
-    -594,    20,    21,    22,    23,    24,    25,    26,     0,     0,
+      15,     0,    16,    17,    18,    19,     0,  -603,  -603,     0,
+    -603,    20,    21,    22,    23,    24,    25,    26,     0,     0,
       27,     0,     0,     0,     0,     0,    28,     0,    30,    31,
       32,    33,    34,    35,    36,    37,    38,    39,     0,    40,
       41,    42,     0,     0,    43,     0,     0,    44,    45,     0,
@@ -2860,1138 +2923,1174 @@ static const yytype_int16 yytable[] =
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,    49,     0,     0,    50,    51,     0,    52,    53,     0,
       54,     0,     0,    55,     0,    56,    57,    58,    59,    60,
-      61,     0,     0,    62,  -594,     0,     0,  -594,  -594,     0,
+      61,     0,     0,    62,  -603,     0,     0,  -603,  -603,   290,
+       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,     0,     0,    63,    64,    65,     0,    15,     0,    16,
+      17,    18,    19,     0,  -603,  -603,     0,  -603,    20,    21,
+      22,    23,    24,    25,    26,     0,     0,    27,     0,     0,
+       0,     0,     0,    28,     0,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,     0,    40,    41,    42,     0,
+       0,    43,     0,     0,    44,    45,     0,    46,    47,    48,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    63,    64,    65,     0,     0,  -594,     0,
-       0,     0,     0,     0,     0,  -594,   284,  -594,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    14,     0,     0,
-    -594,     0,     0,     0,    15,     0,    16,    17,    18,    19,
-       0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
-      25,    26,     0,     0,    27,     0,     0,     0,     0,     0,
-      28,     0,    30,    31,    32,    33,    34,    35,    36,    37,
-      38,    39,     0,    40,    41,    42,     0,     0,    43,     0,
-       0,    44,    45,     0,    46,    47,    48,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    49,     0,
+       0,    50,    51,     0,    52,    53,     0,    54,     0,     0,
+      55,     0,    56,    57,    58,    59,    60,    61,     0,     0,
+      62,  -603,     0,     0,  -603,  -603,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    49,     0,     0,    50,    51,
-       0,    52,    53,     0,    54,     0,     0,    55,     0,    56,
-      57,    58,    59,    60,    61,     0,     0,    62,  -594,     0,
-       0,  -594,  -594,     0,     0,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,     0,     0,    63,    64,    65,
-       0,    15,     0,    16,    17,    18,    19,     0,     0,  -594,
-       0,  -594,    20,    21,    22,    23,    24,    25,    26,     0,
-       0,    27,     0,     0,     0,     0,     0,    28,    29,    30,
+      63,    64,    65,     0,     0,  -603,     0,     0,     0,     0,
+       0,     0,  -603,   290,  -603,     5,     6,     7,     8,     9,
+      10,    11,    12,    13,    14,     0,     0,  -603,     0,     0,
+       0,    15,     0,    16,    17,    18,    19,     0,     0,     0,
+       0,     0,    20,    21,    22,    23,    24,    25,    26,     0,
+       0,    27,     0,     0,     0,     0,     0,    28,     0,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,     0,
       40,    41,    42,     0,     0,    43,     0,     0,    44,    45,
        0,    46,    47,    48,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,    49,     0,     0,    50,    51,     0,    52,    53,
        0,    54,     0,     0,    55,     0,    56,    57,    58,    59,
-      60,    61,     0,     0,    62,   238,     0,     0,   239,   240,
+      60,    61,     0,     0,    62,  -603,     0,     0,  -603,  -603,
        0,     0,     5,     6,     7,     8,     9,    10,    11,    12,
       13,    14,     0,     0,    63,    64,    65,     0,    15,     0,
-      16,    17,    18,    19,     0,     0,   241,     0,   242,    20,
+      16,    17,    18,    19,     0,     0,  -603,     0,  -603,    20,
       21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
-       0,     0,     0,     0,    28,     0,    30,    31,    32,    33,
+       0,     0,     0,     0,    28,    29,    30,    31,    32,    33,
       34,    35,    36,    37,    38,    39,     0,    40,    41,    42,
        0,     0,    43,     0,     0,    44,    45,     0,    46,    47,
       48,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,    49,
        0,     0,    50,    51,     0,    52,    53,     0,    54,     0,
        0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
-       0,    62,   238,     0,     0,   239,   240,     0,     0,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,     0,     0,
+       0,    62,   244,     0,     0,   245,   246,     0,     0,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,     0,
        0,    63,    64,    65,     0,    15,     0,    16,    17,    18,
-      19,     0,     0,   241,     0,   242,    20,    21,    22,    23,
+      19,     0,     0,   247,     0,   248,    20,    21,    22,    23,
       24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
-       0,     0,     0,     0,    31,    32,    33,    34,    35,    36,
+       0,    28,     0,    30,    31,    32,    33,    34,    35,    36,
       37,    38,    39,     0,    40,    41,    42,     0,     0,    43,
        0,     0,    44,    45,     0,    46,    47,    48,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   205,     0,     0,   115,
-      51,     0,    52,    53,     0,     0,     0,     0,    55,     0,
-      56,    57,    58,    59,    60,    61,     0,     0,    62,   238,
-       0,     0,   239,   240,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    63,    64,
-      65,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     241,     0,   242,   125,   126,   127,   128,   129,   130,   131,
-     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,   146,   147,   148,     0,     0,     0,
-     149,   150,   151,   152,   153,   154,   155,   156,   157,   158,
-       0,     0,     0,     0,     0,   159,   160,   161,   162,   163,
-     164,   165,   166,    36,    37,   167,    39,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,     0,
-       0,   177,   178,     0,     0,   179,   180,   181,   182,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   183,
-     184,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,   196,     0,     0,     0,     0,     0,
-       0,   197,   198,  -564,  -564,  -564,  -564,  -564,  -564,  -564,
-    -564,  -564,     0,     0,     0,     0,     0,     0,     0,  -564,
-       0,  -564,  -564,  -564,  -564,     0,  -564,     0,     0,     0,
-    -564,  -564,  -564,  -564,  -564,  -564,  -564,     0,     0,  -564,
-       0,     0,     0,     0,     0,     0,     0,     0,  -564,  -564,
-    -564,  -564,  -564,  -564,  -564,  -564,  -564,     0,  -564,  -564,
-    -564,     0,     0,  -564,     0,     0,  -564,  -564,     0,  -564,
-    -564,  -564,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    -564,     0,     0,  -564,  -564,     0,  -564,  -564,     0,  -564,
-    -564,  -564,  -564,     0,  -564,  -564,  -564,  -564,  -564,  -564,
-       0,     0,  -564,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  -564,  -564,  -564,     0,  -564,     0,     0,     0,
-       0,     0,  -564,  -566,  -566,  -566,  -566,  -566,  -566,  -566,
-    -566,  -566,     0,     0,     0,     0,     0,     0,     0,  -566,
-       0,  -566,  -566,  -566,  -566,     0,  -566,     0,     0,     0,
-    -566,  -566,  -566,  -566,  -566,  -566,  -566,     0,     0,  -566,
-       0,     0,     0,     0,     0,     0,     0,     0,  -566,  -566,
-    -566,  -566,  -566,  -566,  -566,  -566,  -566,     0,  -566,  -566,
-    -566,     0,     0,  -566,     0,     0,  -566,  -566,     0,  -566,
-    -566,  -566,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    -566,     0,     0,  -566,  -566,     0,  -566,  -566,     0,  -566,
-    -566,  -566,  -566,     0,  -566,  -566,  -566,  -566,  -566,  -566,
-       0,     0,  -566,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  -566,  -566,  -566,     0,  -566,     0,     0,     0,
-       0,     0,  -566,  -565,  -565,  -565,  -565,  -565,  -565,  -565,
-    -565,  -565,     0,     0,     0,     0,     0,     0,     0,  -565,
-       0,  -565,  -565,  -565,  -565,     0,  -565,     0,     0,     0,
-    -565,  -565,  -565,  -565,  -565,  -565,  -565,     0,     0,  -565,
-       0,     0,     0,     0,     0,     0,     0,     0,  -565,  -565,
-    -565,  -565,  -565,  -565,  -565,  -565,  -565,     0,  -565,  -565,
-    -565,     0,     0,  -565,     0,     0,  -565,  -565,     0,  -565,
-    -565,  -565,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    -565,     0,     0,  -565,  -565,     0,  -565,  -565,     0,  -565,
-    -565,  -565,  -565,     0,  -565,  -565,  -565,  -565,  -565,  -565,
-       0,     0,  -565,     0,     0,     0,     0,     0,     0,  -567,
-    -567,  -567,  -567,  -567,  -567,  -567,  -567,  -567,     0,     0,
-       0,     0,  -565,  -565,  -565,  -567,  -565,  -567,  -567,  -567,
-    -567,     0,  -565,     0,     0,     0,  -567,  -567,  -567,  -567,
-    -567,  -567,  -567,     0,     0,  -567,     0,     0,     0,     0,
-       0,     0,     0,     0,  -567,  -567,  -567,  -567,  -567,  -567,
-    -567,  -567,  -567,     0,  -567,  -567,  -567,     0,     0,  -567,
-       0,     0,  -567,  -567,     0,  -567,  -567,  -567,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  -567,   771,     0,  -567,
-    -567,     0,  -567,  -567,     0,  -567,  -567,  -567,  -567,     0,
-    -567,  -567,  -567,  -567,  -567,  -567,     0,     0,  -567,     0,
-       0,     0,     0,     0,     0,   -99,  -568,  -568,  -568,  -568,
-    -568,  -568,  -568,  -568,  -568,     0,     0,     0,  -567,  -567,
-    -567,     0,  -568,     0,  -568,  -568,  -568,  -568,  -567,     0,
-       0,     0,     0,  -568,  -568,  -568,  -568,  -568,  -568,  -568,
-       0,     0,  -568,     0,     0,     0,     0,     0,     0,     0,
-       0,  -568,  -568,  -568,  -568,  -568,  -568,  -568,  -568,  -568,
-       0,  -568,  -568,  -568,     0,     0,  -568,     0,     0,  -568,
-    -568,     0,  -568,  -568,  -568,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,  -568,   772,     0,  -568,  -568,     0,  -568,
-    -568,     0,  -568,  -568,  -568,  -568,     0,  -568,  -568,  -568,
-    -568,  -568,  -568,     0,     0,  -568,     0,     0,     0,     0,
-       0,     0,  -101,  -253,  -253,  -253,  -253,  -253,  -253,  -253,
-    -253,  -253,     0,     0,     0,  -568,  -568,  -568,     0,  -253,
-       0,  -253,  -253,  -253,  -253,  -568,     0,     0,     0,     0,
-    -253,  -253,  -253,  -253,  -253,  -253,  -253,     0,     0,  -253,
-       0,     0,     0,     0,     0,     0,     0,     0,  -253,  -253,
-    -253,  -253,  -253,  -253,  -253,  -253,  -253,     0,  -253,  -253,
-    -253,     0,     0,  -253,     0,     0,  -253,  -253,     0,  -253,
-    -253,  -253,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-    -253,     0,     0,  -253,  -253,     0,  -253,  -253,     0,  -253,
-    -253,  -253,  -253,     0,  -253,  -253,  -253,  -253,  -253,  -253,
-       0,     0,  -253,     0,     0,     0,     0,     0,     0,  -569,
-    -569,  -569,  -569,  -569,  -569,  -569,  -569,  -569,     0,     0,
-       0,     0,  -253,  -253,  -253,  -569,     0,  -569,  -569,  -569,
-    -569,     0,   266,     0,     0,     0,  -569,  -569,  -569,  -569,
-    -569,  -569,  -569,     0,     0,  -569,     0,     0,     0,     0,
-       0,     0,     0,     0,  -569,  -569,  -569,  -569,  -569,  -569,
-    -569,  -569,  -569,     0,  -569,  -569,  -569,     0,     0,  -569,
-       0,     0,  -569,  -569,     0,  -569,  -569,  -569,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,  -569,     0,     0,  -569,
-    -569,     0,  -569,  -569,     0,  -569,  -569,  -569,  -569,     0,
-    -569,  -569,  -569,  -569,  -569,  -569,     0,     0,  -569,     0,
-       0,     0,     0,     0,     0,  -570,  -570,  -570,  -570,  -570,
-    -570,  -570,  -570,  -570,     0,     0,     0,     0,  -569,  -569,
-    -569,  -570,     0,  -570,  -570,  -570,  -570,     0,  -569,     0,
-       0,     0,  -570,  -570,  -570,  -570,  -570,  -570,  -570,     0,
-       0,  -570,     0,     0,     0,     0,     0,     0,     0,     0,
-    -570,  -570,  -570,  -570,  -570,  -570,  -570,  -570,  -570,     0,
-    -570,  -570,  -570,     0,     0,  -570,     0,     0,  -570,  -570,
-       0,  -570,  -570,  -570,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,  -570,     0,     0,  -570,  -570,     0,  -570,  -570,
-       0,  -570,  -570,  -570,  -570,     0,  -570,  -570,  -570,  -570,
-    -570,  -570,     0,     0,  -570,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    49,     0,     0,    50,
+      51,     0,    52,    53,     0,    54,     0,     0,    55,     0,
+      56,    57,    58,    59,    60,    61,     0,     0,    62,   244,
+       0,     0,   245,   246,     0,     0,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,     0,     0,     0,    63,    64,
+      65,     0,    15,     0,    16,    17,    18,    19,     0,     0,
+     247,     0,   248,    20,    21,    22,    23,    24,    25,    26,
+       0,     0,    27,     0,     0,     0,     0,     0,     0,     0,
+       0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+       0,    40,    41,    42,     0,     0,    43,     0,     0,    44,
+      45,     0,    46,    47,    48,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,  -570,  -570,  -570,     0,     0,     0,
-       0,     0,     0,     0,  -570,   125,   126,   127,   128,   129,
+       0,     0,     0,   210,     0,     0,   118,    51,     0,    52,
+      53,     0,     0,     0,     0,    55,     0,    56,    57,    58,
+      59,    60,    61,     0,     0,    62,   244,     0,     0,   245,
+     246,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    63,    64,    65,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   247,     0,   248,
      130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
-     140,   141,   142,   143,   144,   145,   146,   147,   148,     0,
-       0,     0,   149,   150,   151,   224,   225,   226,   227,   156,
-     157,   158,     0,     0,     0,     0,     0,   159,   160,   161,
-     228,   229,   230,   231,   166,   309,   310,   232,   311,     0,
-       0,     0,     0,     0,     0,   312,     0,     0,     0,     0,
-       0,     0,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,     0,     0,   177,   178,     0,     0,   179,   180,   181,
-     182,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   183,   184,     0,     0,     0,     0,     0,     0,     0,
-     313,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,   196,     0,     0,     0,
-       0,     0,     0,   197,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     141,   142,   143,   144,   145,   146,   147,   148,     0,     0,
-       0,   149,   150,   151,   224,   225,   226,   227,   156,   157,
-     158,     0,     0,     0,     0,     0,   159,   160,   161,   228,
-     229,   230,   231,   166,   309,   310,   232,   311,     0,     0,
-       0,     0,     0,     0,   312,     0,     0,     0,     0,     0,
-       0,   168,   169,   170,   171,   172,   173,   174,   175,   176,
-       0,     0,   177,   178,     0,     0,   179,   180,   181,   182,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,     0,     0,     0,   154,   155,   156,
+     157,   158,   159,   160,   161,   162,   163,     0,     0,     0,
+       0,     0,   164,   165,   166,   167,   168,   169,   170,   171,
+      36,    37,   172,    39,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,     0,     0,   182,   183,
+       0,     0,   184,   185,   186,   187,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   188,   189,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     183,   184,     0,     0,     0,     0,     0,     0,     0,   433,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   190,
+     191,   192,   193,   194,   195,   196,   197,   198,   199,     0,
+     200,   201,     0,     0,     0,     0,     0,     0,   202,   203,
+    -573,  -573,  -573,  -573,  -573,  -573,  -573,  -573,  -573,     0,
+       0,     0,     0,     0,     0,     0,  -573,     0,  -573,  -573,
+    -573,  -573,     0,  -573,     0,     0,     0,  -573,  -573,  -573,
+    -573,  -573,  -573,  -573,     0,     0,  -573,     0,     0,     0,
+       0,     0,     0,     0,     0,  -573,  -573,  -573,  -573,  -573,
+    -573,  -573,  -573,  -573,     0,  -573,  -573,  -573,     0,     0,
+    -573,     0,     0,  -573,  -573,     0,  -573,  -573,  -573,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   185,   186,   187,   188,   189,   190,   191,
-     192,   193,   194,     0,   195,   196,     0,     0,     0,     0,
-       0,     0,   197,   125,   126,   127,   128,   129,   130,   131,
-     132,   133,   134,   135,   136,   137,   138,   139,   140,   141,
-     142,   143,   144,   145,   146,   147,   148,     0,     0,     0,
-     149,   150,   151,   224,   225,   226,   227,   156,   157,   158,
-       0,     0,     0,     0,     0,   159,   160,   161,   228,   229,
-     230,   231,   166,     0,     0,   232,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,  -573,     0,     0,
+    -573,  -573,     0,  -573,  -573,     0,  -573,  -573,  -573,  -573,
+       0,  -573,  -573,  -573,  -573,  -573,  -573,     0,     0,  -573,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,     0,
-       0,   177,   178,     0,     0,   179,   180,   181,   182,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   183,
-     184,     0,     0,     0,   233,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,  -573,
+    -573,  -573,     0,  -573,     0,     0,     0,     0,     0,  -573,
+    -575,  -575,  -575,  -575,  -575,  -575,  -575,  -575,  -575,     0,
+       0,     0,     0,     0,     0,     0,  -575,     0,  -575,  -575,
+    -575,  -575,     0,  -575,     0,     0,     0,  -575,  -575,  -575,
+    -575,  -575,  -575,  -575,     0,     0,  -575,     0,     0,     0,
+       0,     0,     0,     0,     0,  -575,  -575,  -575,  -575,  -575,
+    -575,  -575,  -575,  -575,     0,  -575,  -575,  -575,     0,     0,
+    -575,     0,     0,  -575,  -575,     0,  -575,  -575,  -575,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,   196,     0,     0,     0,     0,     0,
-       0,   197,   125,   126,   127,   128,   129,   130,   131,   132,
-     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
-     143,   144,   145,   146,   147,   148,     0,     0,     0,   149,
-     150,   151,   224,   225,   226,   227,   156,   157,   158,     0,
-       0,     0,     0,     0,   159,   160,   161,   228,   229,   230,
-     231,   166,     0,     0,   232,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   168,
-     169,   170,   171,   172,   173,   174,   175,   176,     0,     0,
-     177,   178,     0,     0,   179,   180,   181,   182,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   183,   184,
+       0,     0,     0,     0,     0,     0,     0,  -575,     0,     0,
+    -575,  -575,     0,  -575,  -575,     0,  -575,  -575,  -575,  -575,
+       0,  -575,  -575,  -575,  -575,  -575,  -575,     0,     0,  -575,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,  -575,
+    -575,  -575,     0,  -575,     0,     0,     0,     0,     0,  -575,
+    -574,  -574,  -574,  -574,  -574,  -574,  -574,  -574,  -574,     0,
+       0,     0,     0,     0,     0,     0,  -574,     0,  -574,  -574,
+    -574,  -574,     0,  -574,     0,     0,     0,  -574,  -574,  -574,
+    -574,  -574,  -574,  -574,     0,     0,  -574,     0,     0,     0,
+       0,     0,     0,     0,     0,  -574,  -574,  -574,  -574,  -574,
+    -574,  -574,  -574,  -574,     0,  -574,  -574,  -574,     0,     0,
+    -574,     0,     0,  -574,  -574,     0,  -574,  -574,  -574,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   185,   186,   187,   188,   189,   190,   191,   192,   193,
-     194,     0,   195,   196,     0,     0,     0,     0,     0,     0,
-     197,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,     0,     0,     0,     0,    15,     0,   104,
-     105,    18,    19,     0,     0,     0,     0,     0,   106,   107,
-     108,    23,    24,    25,    26,     0,     0,   109,     0,     0,
-       0,     0,     0,     0,     0,     0,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,     0,    40,    41,    42,     0,
-       0,    43,     0,     0,    44,    45,     0,   112,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,  -574,     0,     0,
+    -574,  -574,     0,  -574,  -574,     0,  -574,  -574,  -574,  -574,
+       0,  -574,  -574,  -574,  -574,  -574,  -574,     0,     0,  -574,
+       0,     0,     0,     0,     0,     0,  -576,  -576,  -576,  -576,
+    -576,  -576,  -576,  -576,  -576,     0,     0,     0,     0,  -574,
+    -574,  -574,  -576,  -574,  -576,  -576,  -576,  -576,     0,  -574,
+       0,     0,     0,  -576,  -576,  -576,  -576,  -576,  -576,  -576,
+       0,     0,  -576,     0,     0,     0,     0,     0,     0,     0,
+       0,  -576,  -576,  -576,  -576,  -576,  -576,  -576,  -576,  -576,
+       0,  -576,  -576,  -576,     0,     0,  -576,     0,     0,  -576,
+    -576,     0,  -576,  -576,  -576,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   302,     0,
-       0,   115,    51,     0,    52,    53,     0,     0,     0,     0,
-      55,     0,    56,    57,    58,    59,    60,    61,     0,     0,
-      62,     0,     0,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,     0,     0,     0,     0,     0,     0,     0,    15,
-     116,   104,   105,    18,    19,     0,     0,     0,   303,     0,
-     106,   107,   108,    23,    24,    25,    26,     0,     0,   109,
-       0,     0,     0,     0,     0,     0,     0,     0,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,     0,    40,    41,
-      42,     0,     0,    43,     0,     0,    44,    45,     0,   112,
+       0,     0,     0,  -576,   815,     0,  -576,  -576,     0,  -576,
+    -576,     0,  -576,  -576,  -576,  -576,     0,  -576,  -576,  -576,
+    -576,  -576,  -576,     0,     0,  -576,     0,     0,     0,     0,
+       0,     0,  -107,  -577,  -577,  -577,  -577,  -577,  -577,  -577,
+    -577,  -577,     0,     0,     0,  -576,  -576,  -576,     0,  -577,
+       0,  -577,  -577,  -577,  -577,  -576,     0,     0,     0,     0,
+    -577,  -577,  -577,  -577,  -577,  -577,  -577,     0,     0,  -577,
+       0,     0,     0,     0,     0,     0,     0,     0,  -577,  -577,
+    -577,  -577,  -577,  -577,  -577,  -577,  -577,     0,  -577,  -577,
+    -577,     0,     0,  -577,     0,     0,  -577,  -577,     0,  -577,
+    -577,  -577,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+    -577,   816,     0,  -577,  -577,     0,  -577,  -577,     0,  -577,
+    -577,  -577,  -577,     0,  -577,  -577,  -577,  -577,  -577,  -577,
+       0,     0,  -577,     0,     0,     0,     0,     0,     0,  -109,
+    -265,  -265,  -265,  -265,  -265,  -265,  -265,  -265,  -265,     0,
+       0,     0,  -577,  -577,  -577,     0,  -265,     0,  -265,  -265,
+    -265,  -265,  -577,     0,     0,     0,     0,  -265,  -265,  -265,
+    -265,  -265,  -265,  -265,     0,     0,  -265,     0,     0,     0,
+       0,     0,     0,     0,     0,  -265,  -265,  -265,  -265,  -265,
+    -265,  -265,  -265,  -265,     0,  -265,  -265,  -265,     0,     0,
+    -265,     0,     0,  -265,  -265,     0,  -265,  -265,  -265,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     302,     0,     0,   115,    51,     0,    52,    53,     0,     0,
-       0,     0,    55,     0,    56,    57,    58,    59,    60,    61,
-       0,     0,    62,     0,     0,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,     0,     0,     0,     0,     0,
-       0,    15,   116,    16,    17,    18,    19,     0,     0,     0,
-     557,     0,    20,    21,    22,    23,    24,    25,    26,     0,
-       0,    27,     0,     0,     0,     0,     0,    28,    29,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,     0,
-      40,    41,    42,     0,     0,    43,     0,     0,    44,    45,
-       0,    46,    47,    48,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,  -265,     0,     0,
+    -265,  -265,     0,  -265,  -265,     0,  -265,  -265,  -265,  -265,
+       0,  -265,  -265,  -265,  -265,  -265,  -265,     0,     0,  -265,
+       0,     0,     0,     0,     0,     0,  -578,  -578,  -578,  -578,
+    -578,  -578,  -578,  -578,  -578,     0,     0,     0,     0,  -265,
+    -265,  -265,  -578,     0,  -578,  -578,  -578,  -578,     0,   272,
+       0,     0,     0,  -578,  -578,  -578,  -578,  -578,  -578,  -578,
+       0,     0,  -578,     0,     0,     0,     0,     0,     0,     0,
+       0,  -578,  -578,  -578,  -578,  -578,  -578,  -578,  -578,  -578,
+       0,  -578,  -578,  -578,     0,     0,  -578,     0,     0,  -578,
+    -578,     0,  -578,  -578,  -578,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    49,     0,     0,    50,    51,     0,    52,    53,
-       0,    54,     0,     0,    55,     0,    56,    57,    58,    59,
-      60,    61,     0,     0,    62,     0,     0,     0,     0,     0,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,     0,    63,    64,    65,    15,     0,    16,
-      17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
-      22,    23,    24,    25,    26,     0,     0,   109,     0,     0,
-       0,     0,     0,     0,     0,     0,    31,    32,    33,   251,
-      35,    36,    37,    38,    39,     0,    40,    41,    42,     0,
-       0,    43,     0,     0,    44,    45,     0,    46,    47,    48,
+       0,     0,     0,  -578,     0,     0,  -578,  -578,     0,  -578,
+    -578,     0,  -578,  -578,  -578,  -578,     0,  -578,  -578,  -578,
+    -578,  -578,  -578,     0,     0,  -578,     0,     0,     0,     0,
+       0,     0,  -579,  -579,  -579,  -579,  -579,  -579,  -579,  -579,
+    -579,     0,     0,     0,     0,  -578,  -578,  -578,  -579,     0,
+    -579,  -579,  -579,  -579,     0,  -578,     0,     0,     0,  -579,
+    -579,  -579,  -579,  -579,  -579,  -579,     0,     0,  -579,     0,
+       0,     0,     0,     0,     0,     0,     0,  -579,  -579,  -579,
+    -579,  -579,  -579,  -579,  -579,  -579,     0,  -579,  -579,  -579,
+       0,     0,  -579,     0,     0,  -579,  -579,     0,  -579,  -579,
+    -579,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,  -579,
+       0,     0,  -579,  -579,     0,  -579,  -579,     0,  -579,  -579,
+    -579,  -579,     0,  -579,  -579,  -579,  -579,  -579,  -579,     0,
+       0,  -579,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   455,     0,     0,     0,     0,     0,   205,     0,
-       0,   115,    51,     0,    52,    53,     0,   252,   253,   254,
-      55,     0,    56,    57,    58,    59,    60,    61,     0,     0,
-      62,     0,     0,     0,     0,     0,     0,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,     0,     0,     0,
-      63,   255,    65,    15,     0,    16,    17,    18,    19,     0,
-       0,     0,     0,     0,    20,    21,    22,    23,    24,    25,
-      26,     0,     0,    27,     0,     0,     0,     0,     0,    28,
-       0,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,     0,    40,    41,    42,     0,     0,    43,     0,     0,
-      44,    45,     0,    46,    47,    48,     0,     0,     0,     0,
+       0,  -579,  -579,  -579,     0,     0,     0,     0,     0,     0,
+       0,  -579,   130,   131,   132,   133,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,     0,     0,     0,   154,
+     155,   156,   230,   231,   232,   233,   161,   162,   163,     0,
+       0,     0,     0,     0,   164,   165,   166,   234,   235,   236,
+     237,   171,   315,   316,   238,   317,     0,     0,     0,     0,
+       0,     0,   318,     0,     0,     0,     0,     0,     0,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,     0,     0,
+     182,   183,     0,     0,   184,   185,   186,   187,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   188,   189,
+       0,     0,     0,     0,     0,     0,     0,   319,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,    49,     0,     0,    50,    51,     0,
-      52,    53,     0,    54,     0,     0,    55,     0,    56,    57,
-      58,    59,    60,    61,     0,     0,    62,     0,     0,     0,
-       0,     0,     0,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,     0,     0,     0,     0,    63,    64,    65,    15,
-       0,    16,    17,    18,    19,     0,     0,     0,     0,     0,
-      20,    21,    22,    23,    24,    25,    26,     0,     0,   109,
-       0,     0,     0,     0,     0,     0,     0,     0,    31,    32,
-      33,   251,    35,    36,    37,    38,    39,     0,    40,    41,
-      42,     0,     0,    43,     0,     0,    44,    45,     0,    46,
-      47,    48,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,     0,   200,   201,     0,     0,     0,     0,     0,     0,
+     202,   130,   131,   132,   133,   134,   135,   136,   137,   138,
+     139,   140,   141,   142,   143,   144,   145,   146,   147,   148,
+     149,   150,   151,   152,   153,     0,     0,     0,   154,   155,
+     156,   230,   231,   232,   233,   161,   162,   163,     0,     0,
+       0,     0,     0,   164,   165,   166,   234,   235,   236,   237,
+     171,   315,   316,   238,   317,     0,     0,     0,     0,     0,
+       0,   318,     0,     0,     0,     0,     0,     0,   173,   174,
+     175,   176,   177,   178,   179,   180,   181,     0,     0,   182,
+     183,     0,     0,   184,   185,   186,   187,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   188,   189,     0,
+       0,     0,     0,     0,     0,     0,   477,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     205,     0,     0,   115,    51,     0,    52,    53,     0,   252,
-     253,   254,    55,     0,    56,    57,    58,    59,    60,    61,
-       0,     0,    62,     0,     0,     0,     0,     0,     0,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,     0,     0,
-       0,     0,    63,   255,    65,    15,     0,   104,   105,    18,
-      19,     0,     0,     0,     0,     0,   106,   107,   108,    23,
-      24,    25,    26,     0,     0,   109,     0,     0,     0,     0,
-       0,     0,     0,     0,    31,    32,    33,   251,    35,    36,
-      37,    38,    39,     0,    40,    41,    42,     0,     0,    43,
-       0,     0,    44,    45,     0,    46,    47,    48,     0,     0,
+     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
+       0,   200,   201,     0,     0,     0,     0,     0,     0,   202,
+     130,   131,   132,   133,   134,   135,   136,   137,   138,   139,
+     140,   141,   142,   143,   144,   145,   146,   147,   148,   149,
+     150,   151,   152,   153,     0,     0,     0,   154,   155,   156,
+     230,   231,   232,   233,   161,   162,   163,     0,     0,     0,
+       0,     0,   164,   165,   166,   234,   235,   236,   237,   171,
+       0,     0,   238,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,     0,     0,   182,   183,
+       0,     0,   184,   185,   186,   187,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   188,   189,     0,     0,
+       0,   239,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   190,
+     191,   192,   193,   194,   195,   196,   197,   198,   199,     0,
+     200,   201,     0,     0,     0,     0,     0,     0,   202,   130,
+     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
+     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
+     151,   152,   153,     0,     0,     0,   154,   155,   156,   230,
+     231,   232,   233,   161,   162,   163,     0,     0,     0,     0,
+       0,   164,   165,   166,   234,   235,   236,   237,   171,     0,
+       0,   238,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   173,   174,   175,   176,
+     177,   178,   179,   180,   181,     0,     0,   182,   183,     0,
+       0,   184,   185,   186,   187,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   188,   189,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   205,     0,     0,   115,
-      51,     0,    52,    53,     0,   666,   253,   254,    55,     0,
-      56,    57,    58,    59,    60,    61,     0,     0,    62,     0,
-       0,     0,     0,     0,     0,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,     0,     0,     0,     0,    63,   255,
-      65,    15,     0,   104,   105,    18,    19,     0,     0,     0,
-       0,     0,   106,   107,   108,    23,    24,    25,    26,     0,
-       0,   109,     0,     0,     0,     0,     0,     0,     0,     0,
-      31,    32,    33,   251,    35,    36,    37,    38,    39,     0,
-      40,    41,    42,     0,     0,    43,     0,     0,    44,    45,
-       0,    46,    47,    48,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   190,   191,
+     192,   193,   194,   195,   196,   197,   198,   199,     0,   200,
+     201,     0,     0,     0,     0,     0,     0,   202,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,     0,     0,     0,
+       0,     0,     0,     0,    15,     0,   107,   108,    18,    19,
+       0,     0,     0,     0,     0,   109,   110,   111,    23,    24,
+      25,    26,     0,     0,   112,     0,     0,     0,     0,     0,
+       0,     0,     0,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,     0,    40,    41,    42,     0,     0,    43,     0,
+       0,    44,    45,     0,   115,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   205,     0,     0,   115,    51,     0,    52,    53,
-       0,   252,   253,     0,    55,     0,    56,    57,    58,    59,
-      60,    61,     0,     0,    62,     0,     0,     0,     0,     0,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,     0,    63,   255,    65,    15,     0,   104,
-     105,    18,    19,     0,     0,     0,     0,     0,   106,   107,
-     108,    23,    24,    25,    26,     0,     0,   109,     0,     0,
-       0,     0,     0,     0,     0,     0,    31,    32,    33,   251,
-      35,    36,    37,    38,    39,     0,    40,    41,    42,     0,
-       0,    43,     0,     0,    44,    45,     0,    46,    47,    48,
+       0,     0,     0,     0,     0,   308,     0,     0,   118,    51,
+       0,    52,    53,     0,     0,     0,     0,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,    62,     0,     0,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,     0,
+       0,     0,     0,     0,     0,     0,    15,   119,   107,   108,
+      18,    19,     0,     0,     0,   309,     0,   109,   110,   111,
+      23,    24,    25,    26,     0,     0,   112,     0,     0,     0,
+       0,     0,     0,     0,     0,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,     0,    40,    41,    42,     0,     0,
+      43,     0,     0,    44,    45,     0,   115,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   205,     0,
-       0,   115,    51,     0,    52,    53,     0,     0,   253,   254,
-      55,     0,    56,    57,    58,    59,    60,    61,     0,     0,
-      62,     0,     0,     0,     0,     0,     0,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,     0,     0,     0,     0,
-      63,   255,    65,    15,     0,   104,   105,    18,    19,     0,
-       0,     0,     0,     0,   106,   107,   108,    23,    24,    25,
-      26,     0,     0,   109,     0,     0,     0,     0,     0,     0,
-       0,     0,    31,    32,    33,   251,    35,    36,    37,    38,
-      39,     0,    40,    41,    42,     0,     0,    43,     0,     0,
-      44,    45,     0,    46,    47,    48,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   308,     0,     0,
+     118,    51,     0,    52,    53,     0,     0,     0,     0,    55,
+       0,    56,    57,    58,    59,    60,    61,     0,     0,    62,
+       0,     0,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,    14,     0,     0,     0,     0,     0,     0,    15,   119,
+      16,    17,    18,    19,     0,     0,     0,   599,     0,    20,
+      21,    22,    23,    24,    25,    26,     0,     0,    27,     0,
+       0,     0,     0,     0,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,     0,    40,    41,    42,
+       0,     0,    43,     0,     0,    44,    45,     0,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    49,
+       0,     0,    50,    51,     0,    52,    53,     0,    54,     0,
+       0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
+       0,    62,     0,     0,     0,     0,     0,     0,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,     0,     0,     0,
+       0,    63,    64,    65,    15,     0,    16,    17,    18,    19,
+       0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
+      25,    26,     0,     0,   112,     0,     0,     0,     0,     0,
+       0,     0,     0,    31,    32,    33,   257,    35,    36,    37,
+      38,    39,     0,    40,    41,    42,     0,     0,    43,     0,
+       0,    44,    45,     0,    46,    47,    48,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   499,
+       0,     0,     0,     0,     0,   210,     0,     0,   118,    51,
+       0,    52,    53,     0,   258,   259,   260,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,    62,     0,     0,
+       0,     0,     0,     0,     5,     6,     7,     8,     9,    10,
+      11,    12,    13,    14,     0,     0,     0,    63,   261,    65,
+      15,     0,    16,    17,    18,    19,     0,     0,     0,     0,
+       0,    20,    21,    22,    23,    24,    25,    26,     0,     0,
+      27,     0,     0,     0,     0,     0,    28,     0,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,     0,    40,
+      41,    42,     0,     0,    43,     0,     0,    44,    45,     0,
+      46,    47,    48,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   205,     0,     0,   115,    51,     0,
-      52,    53,     0,   666,   253,     0,    55,     0,    56,    57,
-      58,    59,    60,    61,     0,     0,    62,     0,     0,     0,
-       0,     0,     0,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,     0,     0,     0,     0,    63,   255,    65,    15,
-       0,   104,   105,    18,    19,     0,     0,     0,     0,     0,
-     106,   107,   108,    23,    24,    25,    26,     0,     0,   109,
-       0,     0,     0,     0,     0,     0,     0,     0,    31,    32,
-      33,   251,    35,    36,    37,    38,    39,     0,    40,    41,
-      42,     0,     0,    43,     0,     0,    44,    45,     0,    46,
-      47,    48,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,    49,     0,     0,    50,    51,     0,    52,    53,     0,
+      54,     0,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,     0,     0,    62,     0,     0,     0,     0,     0,     0,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,     0,
+       0,     0,     0,    63,    64,    65,    15,     0,    16,    17,
+      18,    19,     0,     0,     0,     0,     0,    20,    21,    22,
+      23,    24,    25,    26,     0,     0,   112,     0,     0,     0,
+       0,     0,     0,     0,     0,    31,    32,    33,   257,    35,
+      36,    37,    38,    39,     0,    40,    41,    42,     0,     0,
+      43,     0,     0,    44,    45,     0,    46,    47,    48,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     205,     0,     0,   115,    51,     0,    52,    53,     0,     0,
-     253,     0,    55,     0,    56,    57,    58,    59,    60,    61,
-       0,     0,    62,     0,     0,     0,     0,     0,     0,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,     0,     0,
-       0,     0,    63,   255,    65,    15,     0,    16,    17,    18,
-      19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
-      24,    25,    26,     0,     0,   109,     0,     0,     0,     0,
-       0,     0,     0,     0,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,     0,    40,    41,    42,     0,     0,    43,
-       0,     0,    44,    45,     0,    46,    47,    48,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   210,     0,     0,
+     118,    51,     0,    52,    53,     0,   258,   259,   260,    55,
+       0,    56,    57,    58,    59,    60,    61,     0,     0,    62,
+       0,     0,     0,     0,     0,     0,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,     0,     0,     0,     0,    63,
+     261,    65,    15,     0,   107,   108,    18,    19,     0,     0,
+       0,     0,     0,   109,   110,   111,    23,    24,    25,    26,
+       0,     0,   112,     0,     0,     0,     0,     0,     0,     0,
+       0,    31,    32,    33,   257,    35,    36,    37,    38,    39,
+       0,    40,    41,    42,     0,     0,    43,     0,     0,    44,
+      45,     0,    46,    47,    48,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   205,     0,     0,   115,
-      51,     0,    52,    53,     0,   551,     0,     0,    55,     0,
-      56,    57,    58,    59,    60,    61,     0,     0,    62,     0,
-       0,     0,     0,     0,     0,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,     0,     0,     0,     0,    63,   255,
-      65,    15,     0,   104,   105,    18,    19,     0,     0,     0,
-       0,     0,   106,   107,   108,    23,    24,    25,    26,     0,
-       0,   109,     0,     0,     0,     0,     0,     0,     0,     0,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,     0,
-      40,    41,    42,     0,     0,    43,     0,     0,    44,    45,
-       0,    46,    47,    48,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   210,     0,     0,   118,    51,     0,    52,
+      53,     0,   709,   259,   260,    55,     0,    56,    57,    58,
+      59,    60,    61,     0,     0,    62,     0,     0,     0,     0,
+       0,     0,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,     0,     0,     0,     0,    63,   261,    65,    15,     0,
+     107,   108,    18,    19,     0,     0,     0,     0,     0,   109,
+     110,   111,    23,    24,    25,    26,     0,     0,   112,     0,
+       0,     0,     0,     0,     0,     0,     0,    31,    32,    33,
+     257,    35,    36,    37,    38,    39,     0,    40,    41,    42,
+       0,     0,    43,     0,     0,    44,    45,     0,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   210,
+       0,     0,   118,    51,     0,    52,    53,     0,   258,   259,
+       0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
+       0,    62,     0,     0,     0,     0,     0,     0,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,     0,     0,     0,
+       0,    63,   261,    65,    15,     0,   107,   108,    18,    19,
+       0,     0,     0,     0,     0,   109,   110,   111,    23,    24,
+      25,    26,     0,     0,   112,     0,     0,     0,     0,     0,
+       0,     0,     0,    31,    32,    33,   257,    35,    36,    37,
+      38,    39,     0,    40,    41,    42,     0,     0,    43,     0,
+       0,    44,    45,     0,    46,    47,    48,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   205,     0,     0,   115,    51,     0,    52,    53,
-       0,   252,     0,     0,    55,     0,    56,    57,    58,    59,
-      60,    61,     0,     0,    62,     0,     0,     0,     0,     0,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,     0,    63,   255,    65,    15,     0,   104,
-     105,    18,    19,     0,     0,     0,     0,     0,   106,   107,
-     108,    23,    24,    25,    26,     0,     0,   109,     0,     0,
-       0,     0,     0,     0,     0,     0,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,     0,    40,    41,    42,     0,
-       0,    43,     0,     0,    44,    45,     0,    46,    47,    48,
+       0,     0,     0,     0,     0,   210,     0,     0,   118,    51,
+       0,    52,    53,     0,     0,   259,   260,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,    62,     0,     0,
+       0,     0,     0,     0,     5,     6,     7,     8,     9,    10,
+      11,    12,    13,     0,     0,     0,     0,    63,   261,    65,
+      15,     0,   107,   108,    18,    19,     0,     0,     0,     0,
+       0,   109,   110,   111,    23,    24,    25,    26,     0,     0,
+     112,     0,     0,     0,     0,     0,     0,     0,     0,    31,
+      32,    33,   257,    35,    36,    37,    38,    39,     0,    40,
+      41,    42,     0,     0,    43,     0,     0,    44,    45,     0,
+      46,    47,    48,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   205,     0,
-       0,   115,    51,     0,    52,    53,     0,   551,     0,     0,
-      55,     0,    56,    57,    58,    59,    60,    61,     0,     0,
-      62,     0,     0,     0,     0,     0,     0,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,     0,     0,     0,     0,
-      63,   255,    65,    15,     0,   104,   105,    18,    19,     0,
-       0,     0,     0,     0,   106,   107,   108,    23,    24,    25,
-      26,     0,     0,   109,     0,     0,     0,     0,     0,     0,
-       0,     0,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,     0,    40,    41,    42,     0,     0,    43,     0,     0,
-      44,    45,     0,    46,    47,    48,     0,     0,     0,     0,
+       0,   210,     0,     0,   118,    51,     0,    52,    53,     0,
+     709,   259,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,     0,     0,    62,     0,     0,     0,     0,     0,     0,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,     0,
+       0,     0,     0,    63,   261,    65,    15,     0,   107,   108,
+      18,    19,     0,     0,     0,     0,     0,   109,   110,   111,
+      23,    24,    25,    26,     0,     0,   112,     0,     0,     0,
+       0,     0,     0,     0,     0,    31,    32,    33,   257,    35,
+      36,    37,    38,    39,     0,    40,    41,    42,     0,     0,
+      43,     0,     0,    44,    45,     0,    46,    47,    48,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   205,     0,     0,   115,    51,     0,
-      52,    53,     0,   831,     0,     0,    55,     0,    56,    57,
-      58,    59,    60,    61,     0,     0,    62,     0,     0,     0,
-       0,     0,     0,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,     0,     0,     0,     0,    63,   255,    65,    15,
-       0,   104,   105,    18,    19,     0,     0,     0,     0,     0,
-     106,   107,   108,    23,    24,    25,    26,     0,     0,   109,
-       0,     0,     0,     0,     0,     0,     0,     0,    31,    32,
-      33,    34,    35,    36,    37,    38,    39,     0,    40,    41,
-      42,     0,     0,    43,     0,     0,    44,    45,     0,    46,
-      47,    48,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   210,     0,     0,
+     118,    51,     0,    52,    53,     0,     0,   259,     0,    55,
+       0,    56,    57,    58,    59,    60,    61,     0,     0,    62,
+       0,     0,     0,     0,     0,     0,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,     0,     0,     0,     0,    63,
+     261,    65,    15,     0,    16,    17,    18,    19,     0,     0,
+       0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
+       0,     0,   112,     0,     0,     0,     0,     0,     0,     0,
+       0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+       0,    40,    41,    42,     0,     0,    43,     0,     0,    44,
+      45,     0,    46,    47,    48,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     205,     0,     0,   115,    51,     0,    52,    53,     0,   666,
-       0,     0,    55,     0,    56,    57,    58,    59,    60,    61,
-       0,     0,    62,     0,     0,     0,     0,     0,     0,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,     0,     0,
-       0,     0,    63,   255,    65,    15,     0,    16,    17,    18,
-      19,     0,     0,     0,     0,     0,    20,    21,    22,    23,
-      24,    25,    26,     0,     0,    27,     0,     0,     0,     0,
-       0,     0,     0,     0,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,     0,    40,    41,    42,     0,     0,    43,
-       0,     0,    44,    45,     0,    46,    47,    48,     0,     0,
+       0,     0,     0,   210,     0,     0,   118,    51,     0,    52,
+      53,     0,   593,     0,     0,    55,     0,    56,    57,    58,
+      59,    60,    61,     0,     0,    62,     0,     0,     0,     0,
+       0,     0,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,     0,     0,     0,     0,    63,   261,    65,    15,     0,
+     107,   108,    18,    19,     0,     0,     0,     0,     0,   109,
+     110,   111,    23,    24,    25,    26,     0,     0,   112,     0,
+       0,     0,     0,     0,     0,     0,     0,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,     0,    40,    41,    42,
+       0,     0,    43,     0,     0,    44,    45,     0,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   210,
+       0,     0,   118,    51,     0,    52,    53,     0,   258,     0,
+       0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
+       0,    62,     0,     0,     0,     0,     0,     0,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,     0,     0,     0,
+       0,    63,   261,    65,    15,     0,   107,   108,    18,    19,
+       0,     0,     0,     0,     0,   109,   110,   111,    23,    24,
+      25,    26,     0,     0,   112,     0,     0,     0,     0,     0,
+       0,     0,     0,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,     0,    40,    41,    42,     0,     0,    43,     0,
+       0,    44,    45,     0,    46,    47,    48,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   205,     0,     0,   115,
-      51,     0,    52,    53,     0,     0,     0,     0,    55,     0,
-      56,    57,    58,    59,    60,    61,     0,     0,    62,     0,
-       0,     0,     0,     0,     0,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,     0,     0,     0,     0,    63,    64,
-      65,    15,     0,   104,   105,    18,    19,     0,     0,     0,
-       0,     0,   106,   107,   108,    23,    24,    25,    26,     0,
-       0,   109,     0,     0,     0,     0,     0,     0,     0,     0,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,     0,
-      40,    41,    42,     0,     0,    43,     0,     0,    44,    45,
-       0,    46,    47,    48,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   210,     0,     0,   118,    51,
+       0,    52,    53,     0,   593,     0,     0,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,    62,     0,     0,
+       0,     0,     0,     0,     5,     6,     7,     8,     9,    10,
+      11,    12,    13,     0,     0,     0,     0,    63,   261,    65,
+      15,     0,   107,   108,    18,    19,     0,     0,     0,     0,
+       0,   109,   110,   111,    23,    24,    25,    26,     0,     0,
+     112,     0,     0,     0,     0,     0,     0,     0,     0,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,     0,    40,
+      41,    42,     0,     0,    43,     0,     0,    44,    45,     0,
+      46,    47,    48,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   205,     0,     0,   115,    51,     0,    52,    53,
-       0,     0,     0,     0,    55,     0,    56,    57,    58,    59,
-      60,    61,     0,     0,    62,     0,     0,     0,     0,     0,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,     0,    63,   255,    65,    15,     0,    16,
-      17,    18,    19,     0,     0,     0,     0,     0,    20,    21,
-      22,    23,    24,    25,    26,     0,     0,   109,     0,     0,
-       0,     0,     0,     0,     0,     0,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,     0,    40,    41,    42,     0,
-       0,    43,     0,     0,    44,    45,     0,    46,    47,    48,
+       0,   210,     0,     0,   118,    51,     0,    52,    53,     0,
+     874,     0,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,     0,     0,    62,     0,     0,     0,     0,     0,     0,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,     0,
+       0,     0,     0,    63,   261,    65,    15,     0,   107,   108,
+      18,    19,     0,     0,     0,     0,     0,   109,   110,   111,
+      23,    24,    25,    26,     0,     0,   112,     0,     0,     0,
+       0,     0,     0,     0,     0,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,     0,    40,    41,    42,     0,     0,
+      43,     0,     0,    44,    45,     0,    46,    47,    48,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   205,     0,
-       0,   115,    51,     0,    52,    53,     0,     0,     0,     0,
-      55,     0,    56,    57,    58,    59,    60,    61,     0,     0,
-      62,     0,     0,     0,     0,     0,     0,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,     0,     0,     0,     0,
-      63,   255,    65,    15,     0,   104,   105,    18,    19,     0,
-       0,     0,     0,     0,   106,   107,   108,    23,    24,    25,
-      26,     0,     0,   109,     0,     0,     0,     0,     0,     0,
-       0,     0,    31,    32,    33,   110,    35,    36,    37,   111,
-      39,     0,    40,    41,    42,     0,     0,    43,     0,     0,
-      44,    45,     0,   112,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   210,     0,     0,
+     118,    51,     0,    52,    53,     0,   709,     0,     0,    55,
+       0,    56,    57,    58,    59,    60,    61,     0,     0,    62,
+       0,     0,     0,     0,     0,     0,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,     0,     0,     0,     0,    63,
+     261,    65,    15,     0,    16,    17,    18,    19,     0,     0,
+       0,     0,     0,    20,    21,    22,    23,    24,    25,    26,
+       0,     0,    27,     0,     0,     0,     0,     0,     0,     0,
+       0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+       0,    40,    41,    42,     0,     0,    43,     0,     0,    44,
+      45,     0,    46,    47,    48,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   113,     0,     0,   114,     0,     0,   115,    51,     0,
-      52,    53,     0,     0,     0,     0,    55,     0,    56,    57,
-      58,    59,    60,    61,     0,     0,    62,     0,     0,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,     0,     0,
-       0,     0,     0,     0,     0,    15,   116,   104,   105,    18,
-      19,     0,     0,     0,     0,     0,   106,   107,   108,    23,
-      24,    25,    26,     0,     0,   109,     0,     0,     0,     0,
-       0,     0,     0,     0,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,     0,    40,    41,    42,     0,     0,    43,
-       0,     0,    44,    45,     0,   216,     0,     0,     0,     0,
+       0,     0,     0,   210,     0,     0,   118,    51,     0,    52,
+      53,     0,     0,     0,     0,    55,     0,    56,    57,    58,
+      59,    60,    61,     0,     0,    62,     0,     0,     0,     0,
+       0,     0,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,     0,     0,     0,     0,    63,    64,    65,    15,     0,
+     107,   108,    18,    19,     0,     0,     0,     0,     0,   109,
+     110,   111,    23,    24,    25,    26,     0,     0,   112,     0,
+       0,     0,     0,     0,     0,     0,     0,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,     0,    40,    41,    42,
+       0,     0,    43,     0,     0,    44,    45,     0,    46,    47,
+      48,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   210,
+       0,     0,   118,    51,     0,    52,    53,     0,     0,     0,
+       0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
+       0,    62,     0,     0,     0,     0,     0,     0,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,     0,     0,     0,
+       0,    63,   261,    65,    15,     0,    16,    17,    18,    19,
+       0,     0,     0,     0,     0,    20,    21,    22,    23,    24,
+      25,    26,     0,     0,   112,     0,     0,     0,     0,     0,
+       0,     0,     0,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,     0,    40,    41,    42,     0,     0,    43,     0,
+       0,    44,    45,     0,    46,    47,    48,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   217,     0,     0,    50,
-      51,     0,    52,    53,     0,    54,     0,     0,    55,     0,
-      56,    57,    58,    59,    60,    61,     0,     0,    62,     0,
-       0,     5,     6,     7,     8,     9,    10,    11,    12,    13,
-       0,     0,     0,     0,     0,     0,     0,    15,   116,   104,
-     105,    18,    19,     0,     0,     0,     0,     0,   106,   107,
-     108,    23,    24,    25,    26,     0,     0,   109,     0,     0,
-       0,     0,     0,     0,     0,     0,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,     0,    40,    41,    42,     0,
-       0,    43,     0,     0,    44,    45,     0,   112,     0,     0,
+       0,     0,     0,     0,     0,   210,     0,     0,   118,    51,
+       0,    52,    53,     0,     0,     0,     0,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,    62,     0,     0,
+       0,     0,     0,     0,     5,     6,     7,     8,     9,    10,
+      11,    12,    13,     0,     0,     0,     0,    63,   261,    65,
+      15,     0,   107,   108,    18,    19,     0,     0,     0,     0,
+       0,   109,   110,   111,    23,    24,    25,    26,     0,     0,
+     112,     0,     0,     0,     0,     0,     0,     0,     0,    31,
+      32,    33,   113,    35,    36,    37,   114,    39,     0,    40,
+      41,    42,     0,     0,    43,     0,     0,    44,    45,     0,
+     115,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   116,     0,
+       0,   117,     0,     0,   118,    51,     0,    52,    53,     0,
+       0,     0,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,     0,     0,    62,     0,     0,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,     0,     0,     0,     0,     0,
+       0,     0,    15,   119,   107,   108,    18,    19,     0,     0,
+       0,     0,     0,   109,   110,   111,    23,    24,    25,    26,
+       0,     0,   112,     0,     0,     0,     0,     0,     0,     0,
+       0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+       0,    40,    41,    42,     0,     0,    43,     0,     0,    44,
+      45,     0,   222,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   302,     0,
-       0,   349,    51,     0,    52,    53,     0,   350,     0,     0,
-      55,     0,    56,    57,    58,    59,    60,    61,     0,     0,
-      62,     0,     0,     5,     6,     7,     8,     9,    10,    11,
-      12,    13,     0,     0,     0,     0,     0,     0,     0,    15,
-     116,   104,   105,    18,    19,     0,     0,     0,     0,     0,
-     106,   107,   108,    23,    24,    25,    26,     0,     0,   109,
-       0,     0,     0,     0,     0,     0,     0,     0,    31,    32,
-      33,   110,    35,    36,    37,   111,    39,     0,    40,    41,
-      42,     0,     0,    43,     0,     0,    44,    45,     0,   112,
+       0,     0,     0,   223,     0,     0,    50,    51,     0,    52,
+      53,     0,    54,     0,     0,    55,     0,    56,    57,    58,
+      59,    60,    61,     0,     0,    62,     0,     0,     5,     6,
+       7,     8,     9,    10,    11,    12,    13,     0,     0,     0,
+       0,     0,     0,     0,    15,   119,   107,   108,    18,    19,
+       0,     0,     0,     0,     0,   109,   110,   111,    23,    24,
+      25,    26,     0,     0,   112,     0,     0,     0,     0,     0,
+       0,     0,     0,    31,    32,    33,    34,    35,    36,    37,
+      38,    39,     0,    40,    41,    42,     0,     0,    43,     0,
+       0,    44,    45,     0,   115,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   308,     0,     0,   392,    51,
+       0,    52,    53,     0,   393,     0,     0,    55,     0,    56,
+      57,    58,    59,    60,    61,     0,     0,    62,     0,     0,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,     0,
+       0,     0,     0,     0,     0,     0,    15,   119,   107,   108,
+      18,    19,     0,     0,     0,     0,     0,   109,   110,   111,
+      23,    24,    25,    26,     0,     0,   112,     0,     0,     0,
+       0,     0,     0,     0,     0,    31,    32,    33,   113,    35,
+      36,    37,   114,    39,     0,    40,    41,    42,     0,     0,
+      43,     0,     0,    44,    45,     0,   115,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     114,     0,     0,   115,    51,     0,    52,    53,     0,     0,
-       0,     0,    55,     0,    56,    57,    58,    59,    60,    61,
-       0,     0,    62,     0,     0,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,     0,     0,     0,     0,     0,     0,
-       0,    15,   116,   104,   105,    18,    19,     0,     0,     0,
-       0,     0,   106,   107,   108,    23,    24,    25,    26,     0,
-       0,   109,     0,     0,     0,     0,     0,     0,     0,     0,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,     0,
-      40,    41,    42,     0,     0,    43,     0,     0,    44,    45,
-       0,   112,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   117,     0,     0,
+     118,    51,     0,    52,    53,     0,     0,     0,     0,    55,
+       0,    56,    57,    58,    59,    60,    61,     0,     0,    62,
+       0,     0,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,     0,     0,     0,     0,     0,     0,     0,    15,   119,
+     107,   108,    18,    19,     0,     0,     0,     0,     0,   109,
+     110,   111,    23,    24,    25,    26,     0,     0,   112,     0,
+       0,     0,     0,     0,     0,     0,     0,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,     0,    40,    41,    42,
+       0,     0,    43,     0,     0,    44,    45,     0,   115,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   302,     0,     0,   349,    51,     0,    52,    53,
-       0,     0,     0,     0,    55,     0,    56,    57,    58,    59,
-      60,    61,     0,     0,    62,     0,     0,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,     0,     0,     0,     0,
-       0,     0,     0,    15,   116,   104,   105,    18,    19,     0,
-       0,     0,     0,     0,   106,   107,   108,    23,    24,    25,
-      26,     0,     0,   109,     0,     0,     0,     0,     0,     0,
-       0,     0,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,     0,    40,    41,    42,     0,     0,    43,     0,     0,
-      44,    45,     0,   112,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   308,
+       0,     0,   392,    51,     0,    52,    53,     0,     0,     0,
+       0,    55,     0,    56,    57,    58,    59,    60,    61,     0,
+       0,    62,     0,     0,     5,     6,     7,     8,     9,    10,
+      11,    12,    13,     0,     0,     0,     0,     0,     0,     0,
+      15,   119,   107,   108,    18,    19,     0,     0,     0,     0,
+       0,   109,   110,   111,    23,    24,    25,    26,     0,     0,
+     112,     0,     0,     0,     0,     0,     0,     0,     0,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,     0,    40,
+      41,    42,     0,     0,    43,     0,     0,    44,    45,     0,
+     115,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   904,     0,     0,   115,    51,     0,
-      52,    53,     0,     0,     0,     0,    55,     0,    56,    57,
-      58,    59,    60,    61,     0,     0,    62,     0,     0,     5,
-       6,     7,     8,     9,    10,    11,    12,    13,     0,     0,
-       0,     0,     0,     0,     0,    15,   116,   104,   105,    18,
-      19,     0,     0,     0,     0,     0,   106,   107,   108,    23,
-      24,    25,    26,     0,     0,   109,     0,     0,     0,     0,
-       0,     0,     0,     0,    31,    32,    33,    34,    35,    36,
-      37,    38,    39,     0,    40,    41,    42,     0,     0,    43,
-       0,     0,    44,    45,     0,   216,     0,     0,     0,     0,
+       0,   937,     0,     0,   118,    51,     0,    52,    53,     0,
+       0,     0,     0,    55,     0,    56,    57,    58,    59,    60,
+      61,     0,     0,    62,     0,     0,     5,     6,     7,     8,
+       9,    10,    11,    12,    13,     0,     0,     0,     0,     0,
+       0,     0,    15,   119,   107,   108,    18,    19,     0,     0,
+       0,     0,     0,   109,   110,   111,    23,    24,    25,    26,
+       0,     0,   112,     0,     0,     0,     0,     0,     0,     0,
+       0,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+       0,    40,    41,    42,     0,     0,    43,     0,     0,    44,
+      45,     0,   222,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   931,     0,     0,   115,
-      51,     0,    52,    53,     0,   595,   596,     0,    55,   597,
-      56,    57,    58,    59,    60,    61,     0,     0,    62,     0,
-       0,     0,     0,     0,   168,   169,   170,   171,   172,   173,
-     174,   175,   176,     0,     0,   177,   178,     0,   116,   179,
-     180,   181,   182,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   183,   184,     0,     0,     0,     0,     0,
+       0,     0,     0,   960,     0,     0,   118,    51,     0,    52,
+      53,     0,   647,   648,     0,    55,   649,    56,    57,    58,
+      59,    60,    61,     0,     0,    62,     0,     0,     0,     0,
+       0,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+       0,     0,   182,   183,     0,   119,   184,   185,   186,   187,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,   196,   603,
-     604,     0,     0,   605,     0,   197,   266,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,     0,     0,   177,
-     178,     0,     0,   179,   180,   181,   182,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   183,   184,     0,
+     188,   189,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,     0,   200,   201,   668,   640,     0,     0,
+     669,     0,   202,   272,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   173,   174,   175,   176,   177,
+     178,   179,   180,   181,     0,     0,   182,   183,     0,     0,
+     184,   185,   186,   187,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   188,   189,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,   196,   624,   596,     0,     0,   625,     0,   197,
-     266,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,     0,     0,   177,   178,     0,     0,   179,   180,   181,
-     182,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   183,   184,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   190,   191,   192,
+     193,   194,   195,   196,   197,   198,   199,     0,   200,   201,
+     653,   648,     0,     0,   654,     0,   202,   272,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,     0,     0,
+     182,   183,     0,     0,   184,   185,   186,   187,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   188,   189,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,   196,   609,   604,     0,
-       0,   610,     0,   197,   266,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,     0,     0,   177,   178,     0,
-       0,   179,   180,   181,   182,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   183,   184,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-     196,   640,   596,     0,     0,   641,     0,   197,   266,     0,
+       0,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,     0,   200,   201,   683,   640,     0,     0,   684,     0,
+     202,   272,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,     0,     0,   182,   183,     0,     0,   184,   185,
+     186,   187,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   188,   189,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,     0,
-       0,   177,   178,     0,     0,   179,   180,   181,   182,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   183,
-     184,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   190,   191,   192,   193,   194,
+     195,   196,   197,   198,   199,     0,   200,   201,   686,   648,
+       0,     0,   687,     0,   202,   272,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,     0,     0,   182,   183,
+       0,     0,   184,   185,   186,   187,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   188,   189,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,   196,   643,   604,     0,     0,   644,
-       0,   197,   266,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   168,   169,   170,   171,   172,   173,
-     174,   175,   176,     0,     0,   177,   178,     0,     0,   179,
-     180,   181,   182,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   183,   184,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   190,
+     191,   192,   193,   194,   195,   196,   197,   198,   199,     0,
+     200,   201,   693,   640,     0,     0,   694,     0,   202,   272,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,   196,   650,
-     596,     0,     0,   651,     0,   197,   266,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,     0,     0,   177,
-     178,     0,     0,   179,   180,   181,   182,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   183,   184,     0,
+       0,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+       0,     0,   182,   183,     0,     0,   184,   185,   186,   187,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     188,   189,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,   196,   653,   604,     0,     0,   654,     0,   197,
-     266,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,     0,     0,   177,   178,     0,     0,   179,   180,   181,
-     182,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   183,   184,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,     0,   200,   201,   696,   648,     0,     0,
+     697,     0,   202,   272,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   173,   174,   175,   176,   177,
+     178,   179,   180,   181,     0,     0,   182,   183,     0,     0,
+     184,   185,   186,   187,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   188,   189,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,   196,   689,   596,     0,
-       0,   690,     0,   197,   266,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,     0,     0,   177,   178,     0,
-       0,   179,   180,   181,   182,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   183,   184,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   190,   191,   192,
+     193,   194,   195,   196,   197,   198,   199,     0,   200,   201,
+     732,   640,     0,     0,   733,     0,   202,   272,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,     0,     0,
+     182,   183,     0,     0,   184,   185,   186,   187,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   188,   189,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-     196,   692,   604,     0,     0,   693,     0,   197,   266,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,     0,
-       0,   177,   178,     0,     0,   179,   180,   181,   182,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   183,
-     184,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,     0,   200,   201,   735,   648,     0,     0,   736,     0,
+     202,   272,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,     0,     0,   182,   183,     0,     0,   184,   185,
+     186,   187,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   188,   189,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,   196,   836,   596,     0,     0,   837,
-       0,   197,   266,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   168,   169,   170,   171,   172,   173,
-     174,   175,   176,     0,     0,   177,   178,     0,     0,   179,
-     180,   181,   182,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   183,   184,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   190,   191,   192,   193,   194,
+     195,   196,   197,   198,   199,     0,   200,   201,   879,   640,
+       0,     0,   880,     0,   202,   272,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,     0,     0,   182,   183,
+       0,     0,   184,   185,   186,   187,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   188,   189,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,   196,   839,
-     604,     0,     0,   840,     0,   197,   266,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   168,   169,
-     170,   171,   172,   173,   174,   175,   176,     0,     0,   177,
-     178,     0,     0,   179,   180,   181,   182,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   183,   184,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   190,
+     191,   192,   193,   194,   195,   196,   197,   198,   199,     0,
+     200,   201,   882,   648,     0,     0,   883,     0,   202,   272,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   173,   174,   175,   176,   177,   178,   179,   180,   181,
+       0,     0,   182,   183,     0,     0,   184,   185,   186,   187,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-       0,   195,   196,   994,   596,     0,     0,   995,     0,   197,
-     266,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   168,   169,   170,   171,   172,   173,   174,   175,
-     176,     0,     0,   177,   178,     0,     0,   179,   180,   181,
-     182,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   183,   184,     0,     0,     0,     0,     0,     0,     0,
+     188,   189,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   185,   186,   187,   188,   189,   190,
-     191,   192,   193,   194,     0,   195,   196,  1007,   596,     0,
-       0,  1008,     0,   197,   266,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   168,   169,   170,   171,
-     172,   173,   174,   175,   176,     0,     0,   177,   178,     0,
-       0,   179,   180,   181,   182,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   183,   184,     0,     0,     0,
+       0,     0,     0,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,     0,   200,   201,  1019,   640,     0,     0,
+    1020,     0,   202,   272,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   173,   174,   175,   176,   177,
+     178,   179,   180,   181,     0,     0,   182,   183,     0,     0,
+     184,   185,   186,   187,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   188,   189,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   185,   186,
-     187,   188,   189,   190,   191,   192,   193,   194,     0,   195,
-     196,  1010,   604,     0,     0,  1011,     0,   197,   266,     0,
+       0,     0,     0,     0,     0,     0,     0,   190,   191,   192,
+     193,   194,   195,   196,   197,   198,   199,     0,   200,   201,
+    1031,   640,     0,     0,  1032,     0,   202,   272,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   173,
+     174,   175,   176,   177,   178,   179,   180,   181,     0,     0,
+     182,   183,     0,     0,   184,   185,   186,   187,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   188,   189,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     168,   169,   170,   171,   172,   173,   174,   175,   176,     0,
-       0,   177,   178,     0,     0,   179,   180,   181,   182,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   183,
-     184,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   185,   186,   187,   188,   189,   190,   191,   192,
-     193,   194,     0,   195,   196,   609,   604,     0,     0,   610,
-       0,   197,   266,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   168,   169,   170,   171,   172,   173,
-     174,   175,   176,     0,     0,   177,   178,     0,     0,   179,
-     180,   181,   182,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   183,   184,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   732,     0,
-       0,     0,     0,     0,     0,     0,   185,   186,   187,   188,
-     189,   190,   191,   192,   193,   194,     0,   195,   196,     0,
-       0,     0,     0,     0,     0,   197,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,     0,
-       0,   366,   367,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,     0,     0,   366,   367,
+       0,   190,   191,   192,   193,   194,   195,   196,   197,   198,
+     199,     0,   200,   201,  1034,   648,     0,     0,  1035,     0,
+     202,   272,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   173,   174,   175,   176,   177,   178,   179,
+     180,   181,     0,     0,   182,   183,     0,     0,   184,   185,
+     186,   187,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   188,   189,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   368,     0,   369,   370,   371,   372,
-     373,   374,   375,   376,   377,   378,     0,     0,     0,     0,
-       0,   368,     0,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,   353,   354,   355,   356,   357,   358,   359,
-     360,   361,   362,   363,   364,   365,     0,   242,   366,   367,
-       0,     0,   353,   354,   355,   356,   357,   358,   359,   360,
-     361,   362,   363,   364,   365,     0,     0,   366,   367,     0,
+       0,     0,     0,     0,     0,   190,   191,   192,   193,   194,
+     195,   196,   197,   198,   199,     0,   200,   201,   653,   648,
+       0,     0,   654,     0,   202,   272,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   173,   174,   175,
+     176,   177,   178,   179,   180,   181,     0,     0,   182,   183,
+       0,     0,   184,   185,   186,   187,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   188,   189,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   368,     0,   369,   370,   371,   372,   373,   374,   375,
-     376,   377,   378,     0,     0,     0,     0,     0,     0,     0,
-     368,  -260,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,     0,     0,     0,     0,     0,     0,     0,     0,
-    -261,   353,   354,   355,   356,   357,   358,   359,   360,   361,
-     362,   363,   364,   365,     0,     0,   366,   367,     0,     0,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,     0,     0,   366,   367,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   368,
-       0,   369,   370,   371,   372,   373,   374,   375,   376,   377,
-     378,     0,     0,     0,     0,     0,     0,     0,   368,  -262,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-       0,     0,     0,     0,     0,     0,     0,     0,  -263,   353,
-     354,   355,   356,   357,   358,   359,   360,   361,   362,   363,
-     364,   365,     0,     0,   366,   367,     0,     0,     0,   447,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,   364,   365,     0,     0,   366,   367,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   368,     0,   369,
-     370,   371,   372,   373,   374,   375,   376,   377,   378,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   368,     0,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-     353,   354,   355,   356,   357,   358,   359,   360,   361,   362,
-     363,  -595,  -595,     0,     0,   366,   367,   353,   354,   355,
-     356,   357,   358,   359,   360,     0,   362,   363,     0,     0,
-       0,     0,   366,   367,     0,     0,     0,     0,     0,     0,
+       0,   848,     0,     0,     0,     0,     0,     0,     0,   190,
+     191,   192,   193,   194,   195,   196,   197,   198,   199,   859,
+     200,   201,     0,     0,     0,     0,     0,     0,   202,   396,
+     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
+     407,   408,     0,     0,   409,   410,     0,   396,   397,   398,
+     399,   400,   401,   402,   403,   404,   405,   406,   407,   408,
+       0,     0,   409,   410,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   412,     0,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422,     0,
+       0,     0,     0,     0,     0,   412,     0,   413,   414,   415,
+     416,   417,   418,   419,   420,   421,   422,   396,   397,   398,
+     399,   400,   401,   402,   403,   404,   405,   406,   407,   408,
+       0,     0,   409,   410,     0,     0,     0,     0,     0,     0,
+       0,     0,   396,   397,   398,   399,   400,   401,   402,   403,
+     404,   405,   406,   407,   408,     0,     0,   409,   410,     0,
+       0,     0,     0,     0,     0,   412,     0,   413,   414,   415,
+     416,   417,   418,   419,   420,   421,   422,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
-       0,     0,     0,     0,     0,     0,     0,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378,   353,   354,   355,
-     356,   357,   358,   359,     0,     0,   362,   363,     0,     0,
-       0,     0,   366,   367,     0,     0,     0,     0,     0,     0,
+     412,   248,   413,   414,   415,   416,   417,   418,   419,   420,
+     421,   422,     0,     0,     0,     0,     0,     0,     0,     0,
+    -272,   396,   397,   398,   399,   400,   401,   402,   403,   404,
+     405,   406,   407,   408,     0,     0,   409,   410,     0,     0,
+     396,   397,   398,   399,   400,   401,   402,   403,   404,   405,
+     406,   407,   408,     0,     0,   409,   410,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   412,
+       0,   413,   414,   415,   416,   417,   418,   419,   420,   421,
+     422,     0,     0,     0,     0,     0,     0,     0,   412,  -273,
+     413,   414,   415,   416,   417,   418,   419,   420,   421,   422,
+       0,     0,     0,     0,     0,     0,     0,     0,  -274,   396,
+     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
+     407,   408,     0,     0,   409,   410,     0,     0,   396,   397,
+     398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,     0,     0,   409,   410,     0,     0,     0,   411,     0,
+       0,     0,     0,     0,     0,     0,     0,   412,     0,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422,     0,
+       0,     0,     0,     0,     0,     0,   412,  -275,   413,   414,
+     415,   416,   417,   418,   419,   420,   421,   422,   396,   397,
+     398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,     0,     0,   409,   410,     0,     0,     0,   491,   396,
+     397,   398,   399,   400,   401,   402,   403,   404,   405,   406,
+     407,   408,     0,     0,   409,   410,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,   412,     0,   413,   414,
+     415,   416,   417,   418,   419,   420,   421,   422,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   412,     0,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422,   396,
+     397,   398,   399,   400,   401,   402,     0,     0,   405,   406,
+       0,     0,     0,     0,   409,   410,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   369,   370,   371,
-     372,   373,   374,   375,   376,   377,   378
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   413,
+     414,   415,   416,   417,   418,   419,   420,   421,   422
 };
 
 static const yytype_int16 yycheck[] =
 {
-       2,   308,   308,    83,    84,    27,   436,   213,    14,    78,
-       2,    10,     4,     5,     6,    27,    15,     9,    10,    21,
-      85,    13,    28,    15,    16,    17,     7,   262,    20,   381,
-       2,     7,     4,    28,    67,    22,     4,   303,    14,    54,
-     379,    15,   296,   454,   383,   427,   300,   386,    64,   352,
-      52,    53,    28,   405,    50,    16,    17,   721,    50,    20,
-     450,   492,    54,   320,   454,   442,   114,   406,   636,   421,
-      16,    17,    64,   484,    20,    56,   515,   645,   430,   795,
-      56,   420,   709,   422,   912,    26,    78,    57,   889,   391,
-     392,    52,   431,    67,     5,     6,    21,    22,    26,    16,
-     612,   613,    13,   142,    25,   107,    29,   146,    16,    17,
-      89,    91,    20,    25,   101,   285,    58,    59,    60,    61,
-      25,   113,    89,   115,   103,   321,   557,    57,   324,   209,
-     326,   470,   328,    89,   330,    25,    89,   289,    25,   119,
-     220,   293,   494,    54,    52,    53,    25,    16,    17,   119,
-      51,    20,    91,    27,    55,    51,   495,    53,    54,    55,
-      56,    89,   140,    26,     0,    25,   145,    78,   146,   997,
-      16,    17,   136,    69,    20,   103,   101,    91,   145,   349,
-     119,    25,   107,   108,    55,   442,   987,   706,   111,   145,
-      89,   121,   145,   407,    28,   136,   113,   352,   123,   116,
-     117,   281,   509,   509,   740,   119,    52,    53,   136,   745,
-     138,    18,   204,    20,   142,   214,   215,   145,    26,   140,
-     140,   142,   214,   215,   459,   305,   492,   144,   140,   146,
-     142,   947,    50,    80,   303,   140,   391,   392,   750,   113,
-      91,    87,   116,   117,   140,   909,   145,    72,   912,   260,
-     140,   262,   233,   140,   287,   119,    91,   233,   260,    89,
-     262,   140,   295,   296,   266,   676,   893,   300,   119,   243,
-     144,    91,   146,   136,   266,   532,   140,   124,   270,   142,
-     140,    89,   274,   275,   295,   675,   676,   279,   665,   285,
-     119,   557,   284,   285,    91,   103,   140,   115,   729,   119,
-     292,   142,   101,   455,   129,   130,   131,    89,    89,   270,
-     462,   303,   284,   287,   882,   145,    89,   119,    89,   142,
-     292,   473,   119,   123,   270,    55,   632,   126,   136,    89,
-     138,   347,   635,   997,   530,   350,   352,   145,    91,   338,
-     339,   340,   341,   140,   119,   337,   338,   339,   340,   341,
-     342,   343,   344,   349,    25,   347,   404,   349,   350,    91,
-     352,    55,   270,   145,   145,   337,   805,    91,   887,   337,
-     342,   313,   145,    16,   145,   391,   392,   113,   897,   381,
-     116,   117,   734,   822,   823,   145,   347,   119,    89,   381,
-     909,   352,   303,   140,   733,   119,   735,   266,   780,   391,
-     392,   270,   103,   405,   556,   662,    20,   383,   665,   623,
-     386,   140,   414,   405,    60,   407,   408,    63,    57,   421,
-     266,   490,   136,   492,   270,   417,   448,    72,   430,   421,
-     406,    91,   686,   425,   669,   737,   448,   138,   430,   350,
-     742,   743,   119,   435,   145,   143,   422,   458,   459,    91,
-     757,   757,   882,   137,   660,   431,   458,   459,   383,   119,
-     466,   279,   108,   729,   139,   467,    16,   285,    58,    59,
-     113,   466,   883,   116,   117,   467,    55,   119,   439,   631,
-     140,   406,  1001,   457,   476,    37,    38,   567,   557,    91,
-     466,    89,   494,   883,   470,   467,  1015,   422,   490,    91,
-     492,   144,   494,   146,   476,   103,   431,     2,   722,     4,
-     140,   513,   381,   515,     9,    10,    72,   119,    72,   495,
-      15,    16,    17,    91,   963,    20,    98,   119,    91,   786,
-      91,   349,   140,   685,   748,   381,   405,    15,   140,   531,
-     138,    13,   450,   554,   758,   470,   848,   145,   550,    16,
-     608,   119,   421,   611,   789,    50,   119,    15,   119,   405,
-     866,   430,   584,   113,    63,   557,   116,   117,   143,    64,
-     495,   629,   584,   481,   143,   421,   731,   140,    26,   490,
-     137,   492,   737,    89,   430,   140,   800,   742,   743,   113,
-     140,   140,   116,   117,   144,    16,   146,   103,    51,   417,
-      53,    54,    55,    56,   450,    51,   608,   425,   454,   611,
-     612,   613,   140,   600,    44,    89,    69,   435,   113,   140,
-     115,   608,   146,   622,   611,   494,   978,   629,    89,   103,
-     622,   623,   138,   635,   636,   481,   638,   140,   484,   145,
-     979,    89,   103,   645,   796,   859,   557,    51,   494,   660,
-     656,   140,   633,   686,    91,   103,   655,   633,   669,    51,
-     729,   656,   868,   655,   138,    58,    59,   669,   874,    16,
-      17,   145,   140,    20,   635,   600,    62,   138,    64,    65,
-     656,   746,   119,   608,   145,   697,   611,   140,   136,   139,
-     138,   119,   113,   848,   142,   116,   117,   145,    89,   139,
-      47,    48,   627,   140,   629,    52,    53,    17,    18,   204,
-     862,   863,   103,   531,    15,   731,   930,    64,    65,   214,
-     215,   737,   738,   144,    18,   146,   742,   743,   114,   115,
-     722,    51,   734,    53,    54,    55,    56,   729,   730,   731,
-     818,   819,   734,    72,   139,   737,   738,   138,   750,    69,
-     742,   743,   139,   137,   145,    15,   748,   749,   730,   735,
-     137,   763,    26,    91,   766,   139,   758,   675,   146,   768,
-     524,   266,   526,   765,   137,   270,   768,    15,   789,   274,
-     275,    92,    37,    38,   279,   777,   778,   789,    14,   284,
-     285,   119,   113,   785,    15,   116,   117,   292,   127,   128,
-     129,   130,   131,   805,   391,   392,   818,   819,   800,   801,
-     735,    62,   140,    64,    65,    15,   140,   143,   729,    51,
-     822,   823,   144,    57,   140,    89,   140,   140,   820,   675,
-     676,   140,   848,   825,   140,   140,   423,   424,   140,   103,
-      72,   140,   337,   338,   339,   340,   341,   342,   343,   344,
-      15,   139,   347,   933,   349,    15,   848,   352,   113,   137,
-      15,   116,   117,   114,   115,   734,   858,   859,   100,   101,
-      15,    15,   136,   140,   138,   867,     9,    10,   142,   871,
-     882,   145,    15,    15,   471,    89,   381,    89,   734,   144,
-     137,   146,    55,   124,   126,   124,   391,   392,   137,   103,
-      61,   103,    89,    64,    65,   252,   253,   254,   255,   820,
-     405,    15,   407,   408,   825,    89,   103,    55,   140,   266,
-     140,    61,   417,   270,    64,    65,   421,   949,    15,   103,
-     425,   749,   140,   140,   138,   430,   138,   949,   930,   140,
-     435,   145,   706,   145,   936,   709,   938,   765,    89,   941,
-      15,   138,   140,   114,   115,   142,   867,   721,   145,   777,
-     778,   963,   103,   140,   138,   113,   142,   785,   116,   117,
-     142,   145,   467,   139,   114,   115,   978,   467,   980,   981,
-     113,   476,   140,   801,    13,    26,   978,     6,   981,   987,
-      63,    64,    65,   721,   980,   207,   144,   138,   146,   494,
-     347,   213,   747,   979,   145,   352,   353,   354,   355,   356,
-     357,   358,   359,   360,   361,   362,   363,   364,   365,   366,
-     367,   368,   369,   370,   371,   372,   373,   374,   375,   376,
-     377,   378,   245,     7,   381,   721,   531,   883,   250,   866,
-     858,   114,   115,   700,   391,   392,   261,   906,    89,    26,
-      89,   909,   706,   871,   979,   809,   810,   811,   405,   813,
-      -1,   815,   103,    -1,   103,    89,    -1,     2,    -1,     4,
-       5,     6,   419,    -1,   421,    -1,   423,   424,    13,   103,
-      -1,   214,   215,   430,    89,    -1,    -1,    63,    64,    65,
-      -1,    -1,   439,    -1,    -1,   136,   443,   138,   103,   138,
-     447,   142,    -1,   450,   145,   452,   145,   454,    -1,   978,
-      -1,    -1,    89,    -1,   138,    50,    -1,    89,   936,    54,
-     938,   145,    -1,   941,   471,   337,   103,   622,   623,   893,
-      -1,   103,   978,   138,   481,    -1,    -1,   484,   114,   115,
-     145,   274,   275,    78,    -1,   909,    -1,   494,   912,    -1,
-     737,   738,    -1,    -1,    -1,   742,   743,    -1,    -1,   136,
-     655,   138,    -1,    -1,   511,   142,   138,    -1,   145,    -1,
-     696,    -1,    -1,   145,    51,   522,    53,    54,    55,    56,
-     115,    -1,    -1,   709,   771,   772,   712,   774,   775,    63,
-      64,    65,    69,   540,   541,   721,    -1,    -1,    -1,    -1,
-     954,   955,   956,   957,   551,   338,   339,   340,   341,    -1,
-     343,   344,    -1,    -1,   426,   427,    93,   700,    -1,    -1,
-     906,   704,    99,   909,   700,    -1,   912,   722,   914,    63,
-      64,    65,    -1,   997,    -1,   730,   731,    -1,   721,   734,
-     114,   115,   737,   738,    -1,   721,    -1,   742,   743,    63,
-      64,    65,    -1,   748,   749,    -1,    -1,    -1,    63,    64,
-      65,   848,    -1,   758,   476,  1019,    -1,    -1,    -1,   204,
-     765,   483,    -1,   768,    -1,   408,    -1,    -1,   964,    -1,
-     114,   115,   777,   778,    -1,    -1,    -1,    -1,   635,   876,
-     785,    40,    41,    42,    43,    44,    -1,     2,    -1,     4,
-     114,   115,    -1,    -1,    -1,   800,   801,    -1,    13,   114,
-     115,   997,    -1,   999,    -1,  1001,    -1,  1003,    -1,   666,
-      63,    64,    65,    -1,    -1,    -1,    -1,    -1,   675,   676,
-      -1,    -1,    -1,    51,    -1,    53,    54,    55,    56,    -1,
-      -1,    -1,  1028,    -1,   279,    50,    63,    64,    65,   284,
-     285,    69,    -1,   848,    72,    -1,    -1,   292,    -1,    -1,
-      -1,    -1,    -1,   858,   859,   827,   828,   893,   303,   895,
-      -1,   114,   115,   899,    -1,    93,   871,    -1,    -1,   726,
-      -1,    99,   100,   101,   731,   732,   912,   734,   914,    -1,
-     737,   738,    -1,    -1,    -1,   742,   743,   114,   115,    -1,
-      -1,    -1,   337,    -1,    -1,    -1,    -1,   342,   126,   621,
-     115,   129,    -1,    -1,   349,   350,    -1,   352,    -1,   945,
-     946,    -1,   140,   906,   771,   772,   909,   774,   775,   912,
-     906,   914,    -1,   909,    -1,   930,   912,   784,   914,    -1,
-      -1,   936,    -1,   938,    -1,    -1,   941,   909,   660,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   391,   392,    -1,   985,
-      -1,    -1,    -1,     2,   990,     4,     5,     6,     7,    -1,
-      -1,   997,   407,   999,    13,    -1,    -1,  1003,    -1,    -1,
-      -1,   964,   417,   978,   831,    -1,    -1,    -1,   964,   622,
-     425,  1017,    -1,    -1,   841,   842,    -1,    -1,    -1,   204,
-     435,   848,  1028,    -1,    -1,   967,   968,   969,    -1,   971,
-     972,    50,    -1,    -1,   997,    54,   999,    -1,  1001,    -1,
-    1003,   997,   655,   999,    -1,  1001,    -1,  1003,    -1,   876,
-      -1,    -1,   467,    -1,    72,    -1,   883,    -1,    -1,    78,
-     752,   476,    -1,    -1,    -1,  1028,    -1,   759,    -1,    87,
-      88,    72,  1028,    -1,     2,   490,     4,   492,  1020,  1021,
-    1022,  1023,    72,    -1,    -1,    -1,    87,    88,   780,    -1,
-    1032,    -1,    -1,    -1,   279,    -1,   115,    87,    88,   284,
-     285,    51,    -1,    53,    54,    55,    56,   292,   126,   127,
-     128,   129,   130,   131,   113,    -1,   531,   116,   117,    69,
-      -1,    -1,    50,   124,   125,   126,   127,   128,   129,   130,
-     131,    -1,    -1,    -1,    -1,    -1,    -1,   127,   128,   129,
-     130,   131,   557,    93,   143,   144,    -1,   146,    -1,    99,
-     113,   978,   337,   116,   117,   768,    51,   342,    53,    54,
-      55,    56,    -1,    -1,   349,    -1,    -1,   352,    51,    -1,
-      53,    54,    55,    56,    69,    -1,   868,   140,    -1,    -1,
-      -1,   144,   874,   146,    -1,   204,    69,   115,    -1,    72,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    93,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   391,   392,   623,    -1,
-      93,    -1,    -1,    -1,    -1,    -1,    99,   100,   101,    -1,
-      -1,    51,   407,    53,    54,    55,    56,    -1,    -1,    -1,
-      -1,    -1,   417,    -1,    -1,    -1,    -1,    -1,    -1,    69,
-     425,    -1,    72,   126,    -1,    -1,   129,    -1,    -1,    -1,
-     435,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   142,
-     279,    -1,    -1,    93,    -1,   284,   285,    -1,    -1,    99,
-     100,   101,    -1,   292,    -1,    -1,   204,    -1,    -1,    -1,
-      -1,    -1,   467,    -1,   303,    -1,    -1,    -1,    -1,    -1,
-      51,   476,    53,    54,    55,    56,   126,    -1,    -1,   129,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   722,    69,    -1,
-      -1,    72,   142,    -1,   729,   730,   731,    -1,   337,    -1,
-      -1,    -1,   737,   342,    -1,    -1,    -1,   742,   743,    -1,
-     349,   350,    93,   748,   749,    -1,    -1,    -1,    99,   100,
-     101,    -1,    -1,   758,    -1,    -1,   531,    -1,    -1,    -1,
-     765,   279,    -1,    -1,    -1,    -1,   284,   285,    -1,    -1,
-      -1,    -1,   777,   778,   292,   126,    -1,    -1,   129,    -1,
-     785,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   800,   801,    -1,   407,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    51,   417,    53,
-      54,    55,    56,    -1,    -1,   820,   425,    -1,    -1,   337,
-     825,    -1,    -1,    -1,   342,    69,   435,    -1,    72,    -1,
-      -1,   349,    -1,    -1,   352,    -1,    -1,    -1,    -1,    -1,
-      84,    -1,    -1,   848,    -1,    -1,    -1,    -1,   623,    93,
-      -1,    -1,    -1,   858,   859,    99,   100,   101,   467,    -1,
-      -1,    -1,   867,    -1,    -1,    -1,   871,   476,    -1,    -1,
-      -1,    -1,    -1,   391,   392,    -1,    -1,    -1,    -1,    -1,
-      -1,   490,   126,   492,    -1,   129,    -1,    -1,    51,   407,
-      53,    54,    55,    56,    -1,    -1,    -1,    -1,    -1,   417,
-      -1,    -1,    -1,    -1,    -1,    -1,    69,   425,    -1,    72,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   435,    -1,    -1,
-      -1,    -1,   531,    -1,    -1,   930,    -1,    -1,    -1,    -1,
-      93,   936,    -1,   938,    -1,    -1,   941,   100,   101,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   722,   557,   467,
-      -1,    -1,    -1,    -1,    -1,   730,   731,    -1,   476,    -1,
-      -1,    -1,   737,   126,    -1,    -1,    -1,   742,   743,    -1,
-      -1,    -1,    -1,   748,   749,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   758,    -1,    -1,    -1,    -1,    -1,    -1,
-     765,     0,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   777,   778,    13,    14,    15,    16,    17,    18,
-     785,    20,    -1,   531,   623,    -1,    -1,    26,    27,    -1,
-      -1,    -1,    -1,    -1,    -1,   800,   801,    -1,    37,    38,
-      -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+       2,    16,    17,    88,   219,    20,    86,    87,   471,    81,
+       2,    27,     4,     5,     6,    27,    14,     9,    10,    21,
+       7,    13,   768,    15,    16,    17,   480,   372,    20,    13,
+      28,     7,    28,    67,    22,   117,   584,    10,    14,   268,
+     302,     4,    15,     2,   306,     4,    73,    74,    26,    54,
+      52,    53,    28,   486,   395,   679,   498,   581,    50,    16,
+      17,   745,    54,    20,   688,    26,   314,    16,    17,    56,
+      15,    20,    64,    16,    17,   581,   945,    20,   584,    50,
+      56,   656,   657,   435,   436,   266,   528,   268,   494,    81,
+       5,     6,   498,   120,   121,    52,    53,   309,    13,   291,
+     536,    37,    38,    52,    53,    21,    22,   923,   110,    52,
+      29,    57,    37,    38,   787,    27,   104,   365,    57,   792,
+     301,    91,    67,     0,   116,   326,   118,   423,    80,    91,
+      18,   427,    20,    90,   430,   215,   425,     5,     6,    54,
+      74,    58,    59,    60,    61,    13,   226,    16,    17,   119,
+      55,    20,    92,  1022,   140,   451,    50,   119,   136,    89,
+     146,   450,   327,   599,   142,   330,    81,   332,   464,   334,
+     466,   336,   124,   119,   140,   136,   465,   113,   140,   475,
+     116,   117,   121,    58,    59,   474,    54,   121,   104,    89,
+      51,    28,   111,    91,   110,   111,   942,  1013,    89,   945,
+     392,   113,    89,   103,   116,   117,   119,   287,   144,   119,
+     146,    72,   128,    81,   136,   145,   103,   209,   514,    58,
+      59,   119,   797,    89,   118,    17,    18,    89,   220,   221,
+     140,   311,   144,   119,   146,    89,   142,   309,   138,   100,
+     101,   395,   142,   539,   928,   145,   101,   220,   221,   538,
+      72,   138,   239,   140,   145,   142,    64,   272,   145,   293,
+      89,   276,   768,   239,   266,   126,   268,   301,   302,   142,
+     272,   126,   306,   146,   503,   708,  1022,   719,    89,   145,
+     272,   435,   436,   145,   276,   486,    89,   314,   280,   281,
+      89,   145,   540,   285,    89,    91,   920,   142,   290,   291,
+     103,    26,   850,   123,   249,   367,   298,   129,   130,   131,
+      89,    55,   718,   719,    51,   272,   145,   309,    55,   276,
+     291,   502,   503,   847,   536,   387,   119,   276,     5,     6,
+     854,   290,    91,   276,   145,   138,    13,   678,   365,   298,
+     776,    91,   145,    91,   850,   546,   145,    55,   293,    89,
+     145,   343,   344,   345,   346,   347,   348,   349,   350,   351,
+     119,   824,    25,   103,    89,   349,   145,   449,   370,   119,
+     372,   344,   345,   346,   347,   367,   140,    54,   103,   544,
+     343,   140,    60,    20,   343,    63,    91,   599,   393,   348,
+     452,   285,   861,   862,   309,   387,    91,   291,   390,   140,
+     392,   393,   319,   395,    81,   145,    57,   276,   136,   754,
+     425,   136,    91,   138,   119,   596,    72,   142,   942,   411,
+     145,   392,   143,   425,   119,    91,   137,   411,   652,   119,
+     108,   655,   784,   425,   349,   450,   942,   789,   790,   945,
+     119,   309,    91,   435,   436,   140,    55,   390,   450,   673,
+     465,   427,   395,   119,   430,   139,   458,    91,   450,   474,
+     452,   453,   534,   465,   536,   140,   920,   729,   425,   461,
+     119,    72,   474,   465,   140,   451,   492,   469,   393,   921,
+     492,   349,   474,   712,   780,   119,   782,   479,   703,    72,
+     466,  1015,   781,   450,    73,    74,   411,   119,   392,   475,
+     502,   503,  1026,    51,   705,    91,   140,   708,   465,   511,
+     140,   427,   510,   540,   510,   921,  1022,   474,    51,   511,
+     865,   866,   703,   538,   140,   393,   140,   599,   520,   609,
+      91,   712,    91,   119,   510,   451,   538,   494,   514,   891,
+     483,   498,   534,   411,   536,   494,   538,   140,   140,   119,
+     466,    91,   511,   545,   140,    51,   501,    98,   119,   475,
+     119,   520,    16,   539,   776,    91,    91,   461,   525,   295,
+      15,   528,   140,   299,    13,   469,   525,    89,    16,   119,
+      63,   538,   390,    72,    15,   479,   143,   395,   143,   140,
+     592,   103,   137,   119,   119,     2,   113,     4,   514,   116,
+     117,    15,     9,    10,   833,   667,    15,   599,    15,    16,
+      17,   113,   628,    20,   116,   117,   628,    16,   140,   534,
+     381,   536,   383,   539,   778,    44,   138,   435,   436,   830,
+     784,    89,   309,   145,   119,   789,   790,   212,   127,   128,
+     129,   130,   131,    50,   219,   103,   139,   139,    15,   994,
+     652,   545,   833,   655,   656,   657,   644,    64,    18,   113,
+     139,   139,   116,   117,   652,   137,   534,   655,   536,    15,
+     137,   673,   349,   139,   666,   667,   678,   679,   146,   681,
+     138,   256,   140,   140,   599,   137,   688,   145,    57,   676,
+     144,   906,   146,   666,   140,   729,   140,   912,   140,   140,
+     676,   699,    15,   699,   776,    92,   698,   769,   793,   116,
+     712,   118,    14,  1009,   113,    89,   393,   116,   117,  1008,
+      15,   737,    15,   699,   144,   698,   143,   140,   644,   103,
+     140,   599,    89,   795,   411,   678,   652,   891,   140,   655,
+     140,   140,   435,   436,   140,   144,   103,   146,    26,    15,
+     139,    89,   754,    15,   137,   671,    61,   673,    26,    64,
+      65,   718,   719,    15,   138,   103,   781,    15,   343,   718,
+      15,   145,   137,   499,   467,   468,   140,   769,   840,   781,
+     506,   138,   124,   140,   776,   777,   778,   124,   145,   781,
+      55,   517,   784,   785,   137,   797,   568,   789,   790,   374,
+     138,    15,   209,   795,   796,   807,   782,   145,   810,   114,
+     115,    89,   584,   220,   221,   587,    55,   809,   777,   140,
+     812,    89,   515,   113,   781,   103,   116,   117,   140,   821,
+     822,   833,   140,   140,   140,   103,   140,   829,   139,   812,
+     902,    15,   142,   569,   570,   861,   862,   574,   840,   841,
+     142,   578,   140,   511,   574,     6,   146,   534,   136,   536,
+     138,   776,   140,   865,   866,   272,   782,   145,   136,   276,
+     138,   863,   598,   280,   281,  1011,   868,   145,   285,   768,
+    1013,  1010,   962,   290,   291,    51,   794,    53,    54,    55,
+      56,   298,   251,     7,   574,   470,   471,    61,   939,   891,
+      64,    65,   796,    69,   942,     9,    10,   581,   776,   901,
+     902,    15,    89,   905,   267,   809,    89,   909,   920,    -1,
+      -1,    -1,   599,    -1,    -1,    -1,   103,   821,   822,    -1,
+     103,    -1,    -1,    -1,    -1,   829,   343,   344,   345,   346,
+     347,   348,    -1,   350,   351,   520,    -1,   841,   863,   675,
+     114,   115,   527,   868,    -1,    89,    -1,    -1,    -1,   975,
+     367,   138,    -1,   975,   921,   138,    -1,   140,   145,   103,
+     778,    -1,   145,   965,   140,   967,   784,   785,   970,    -1,
+     387,   789,   790,   390,    -1,   392,    -1,    -1,   395,    -1,
+     905,    89,   994,  1008,    -1,   863,   768,   758,   759,   760,
+     868,   762,   728,   764,   138,   103,  1008,   901,  1010,  1011,
+      -1,   145,   116,    -1,    -1,   909,  1008,    -1,   425,   113,
+     746,    -1,   116,   117,    26,    89,    -1,    -1,   435,   436,
+      -1,    -1,    -1,  1009,   870,   871,    -1,   905,    -1,   103,
+     138,   768,    -1,   450,    -1,   452,   453,   145,   768,   143,
+     144,  1008,   146,    72,   461,   768,    -1,    -1,   465,    16,
+      -1,    51,   469,    53,    54,    55,    56,   474,    87,    88,
+      -1,   965,   479,   967,   138,    -1,   970,    -1,   850,    69,
+     852,   145,    -1,   891,   856,    -1,    -1,    89,    89,    -1,
+     665,   784,   785,  1009,    -1,    -1,   789,   790,    -1,   776,
+      -1,   103,   103,    16,   511,    -1,   942,   126,   127,   128,
+     129,   130,   131,   520,    -1,    -1,   220,   221,    -1,    -1,
+      -1,    -1,   815,   816,    -1,   818,   819,    -1,   703,    -1,
+      62,   538,    64,    65,   136,    -1,   138,   138,   545,    89,
+     142,     9,    10,   145,   145,    -1,    -1,    15,    16,    17,
+     140,    -1,    20,   103,   926,   927,   113,    -1,    -1,   116,
+     117,    -1,   998,   999,  1000,    -1,  1002,  1003,    -1,   930,
+     931,   932,   933,   945,    26,   947,   280,   281,    -1,    47,
+      48,    -1,   114,   115,    52,    53,   863,   144,   138,   146,
+      -1,   868,    -1,    -1,    -1,   145,    64,    65,   891,    -1,
+     113,    -1,    -1,   116,   117,    -1,  1042,  1043,  1044,  1045,
+     982,    -1,   939,   985,    -1,   942,  1052,    26,   945,   939,
+     947,   914,   942,    -1,   799,   945,   939,   947,   905,   942,
+      -1,   144,   945,   146,   947,    26,    -1,    89,    -1,    -1,
+     344,   345,   346,   347,    -1,  1017,   350,   351,   116,   824,
+    1022,   103,  1024,    26,    -1,    -1,  1028,  1018,    89,   666,
+     667,    51,    -1,    53,    54,    55,    56,    -1,   995,    89,
+      -1,    -1,   103,    -1,    -1,   995,  1048,    -1,    -1,    69,
+      89,    -1,   995,   103,   136,    -1,   138,    26,   140,    -1,
+     142,   698,    -1,   145,   103,  1022,    -1,  1024,    89,  1026,
+      -1,  1028,  1022,    93,  1024,    -1,  1026,   138,  1028,  1022,
+      89,  1024,   103,  1026,   145,  1028,    89,    -1,   138,    -1,
+      -1,  1048,    -1,    -1,   103,   145,    -1,   136,  1048,   138,
+     103,   906,    26,   142,    -1,  1048,   145,   912,    51,    -1,
+      53,    54,    55,    56,    -1,   136,    -1,   138,    -1,   453,
+      89,   142,   220,   221,   145,    -1,    69,    -1,    -1,   138,
+      -1,    89,   769,   136,   103,   138,   145,   140,    -1,   142,
+     777,   778,   145,    -1,   781,   103,    -1,   784,   785,    63,
+      64,    65,   789,   790,    62,    -1,    64,    65,   795,   796,
+     258,   259,   260,   261,    -1,    89,    -1,   136,    -1,   138,
+      -1,   140,   809,   142,   272,   812,   145,    -1,   276,   103,
+     138,    -1,   280,   281,   821,   822,    -1,   145,    -1,    -1,
+      -1,    -1,   829,    63,    64,    65,    -1,    -1,    -1,    -1,
+     114,   115,    -1,   840,   841,    -1,   114,   115,    -1,    63,
+      64,    65,   136,    -1,   138,    63,    64,    65,   142,    72,
+      -1,   145,    -1,    -1,   113,    -1,    -1,   116,   117,    -1,
+      -1,    63,    64,    65,    87,    88,    -1,    -1,    51,    -1,
+      53,    54,    55,    56,   114,   115,   344,   345,   346,   347,
+      -1,   140,   350,   351,   891,   144,    69,   146,    -1,    72,
+     114,   115,    -1,    -1,   901,   902,   114,   115,    -1,    -1,
+     368,    -1,   909,    -1,   127,   128,   129,   130,   131,    -1,
+      93,   379,   114,   115,    63,    64,    65,   100,   101,    -1,
+      -1,    -1,   390,    63,    64,    65,    -1,   395,   396,   397,
+     398,   399,   400,   401,   402,   403,   404,   405,   406,   407,
+     408,   409,   410,   126,   412,   413,   414,   415,   416,   417,
+     418,   419,   420,   421,   422,    72,    -1,   425,   965,    -1,
+     967,    -1,   666,   970,    -1,   114,   115,   435,   436,    -1,
+      87,    88,    -1,    -1,   114,   115,    -1,     2,    -1,     4,
+       5,     6,   450,    -1,    -1,   453,    -1,   113,    13,    -1,
+     116,   117,    -1,    -1,   698,   463,    -1,   465,    -1,   467,
+     468,  1008,    63,    64,    65,    -1,   474,   124,   125,   126,
+     127,   128,   129,   130,   131,   483,    -1,    -1,   144,   487,
+     146,    -1,    -1,   491,     0,    50,   494,    -1,   496,    54,
+     498,    51,    -1,    53,    54,    55,    56,    13,    14,    15,
+      16,    17,    18,    -1,    20,    -1,    -1,   515,    -1,    69,
+      26,    27,    72,   114,   115,    -1,    81,   525,    -1,    -1,
+     528,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
+     538,    -1,    -1,    93,    40,    41,    42,    43,    44,    99,
+     100,   101,    -1,    -1,    -1,    -1,   554,   555,    -1,    -1,
+      -1,    -1,    -1,   118,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   571,    -1,    -1,   126,    -1,   812,   129,
+      -1,    -1,    -1,    89,    51,    -1,    53,    54,    55,    56,
+     140,    -1,   590,    -1,    -1,   593,    -1,   103,    -1,    -1,
+      -1,    -1,    69,    -1,    -1,    72,    -1,   113,    -1,    -1,
+     116,   117,     2,    -1,     4,     5,     6,     7,    -1,    -1,
+      -1,    -1,    -1,    13,    -1,    -1,    93,    -1,    -1,    -1,
+     136,   137,    99,   100,   101,    -1,   142,   143,   144,   145,
+     146,    -1,     2,    -1,     4,    51,    -1,    53,    54,    55,
+      56,    -1,    -1,    13,   209,    -1,    -1,    -1,    -1,   126,
+      50,    -1,   129,    69,    54,    -1,    -1,    51,   666,    53,
+      54,    55,    56,    -1,    -1,   142,    -1,    -1,    -1,    -1,
+     678,    -1,    -1,    -1,    -1,    69,    -1,    93,    -1,    -1,
+      50,    81,    51,    99,    53,    54,    55,    56,    -1,    -1,
+     698,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    93,
+      69,   709,    -1,    72,    -1,    99,    -1,    -1,    -1,    -1,
+     718,   719,    -1,    -1,    -1,    51,    52,    -1,   118,    55,
+     285,    -1,    -1,    -1,    93,   290,   291,    -1,    -1,    -1,
+      99,   100,   101,   298,    70,    71,    72,    73,    74,    75,
+      76,    77,    78,    -1,   309,    81,    82,    -1,   118,    85,
+      86,    87,    88,    -1,    -1,    -1,    -1,   126,    -1,    -1,
+     129,    -1,    -1,    99,   100,   773,    -1,    -1,    -1,    -1,
+     778,   779,    -1,   781,    -1,    -1,   784,   785,   343,    -1,
+      -1,   789,   790,   348,   349,    -1,   122,   123,   124,   125,
+     126,   127,   128,   129,   130,   131,    -1,   133,   134,    -1,
+      -1,    -1,   367,    -1,   812,   141,   142,   815,   816,   209,
+     818,   819,    -1,    -1,    51,    -1,    53,    54,    55,    56,
+     828,    -1,   387,    -1,    -1,    -1,    -1,   392,   393,    -1,
+     395,    -1,    69,    -1,    -1,    72,    -1,    -1,    -1,   209,
+     848,    -1,    -1,    -1,    -1,    -1,   411,    -1,    -1,    -1,
+      -1,   859,    -1,    -1,    -1,    -1,    93,    -1,    -1,    -1,
+      -1,    -1,    99,   100,   101,    -1,   874,    -1,    -1,    -1,
+     435,   436,    -1,    -1,    -1,    -1,   884,   885,    -1,    -1,
+      -1,    -1,    -1,   891,    -1,   285,    -1,   452,    -1,   126,
+     290,   291,   129,    -1,    -1,    -1,   461,    -1,   298,    -1,
+      -1,    -1,    -1,    -1,   469,   142,   914,    -1,    -1,   309,
+      -1,    -1,    -1,   921,   479,   285,    -1,    -1,    -1,    -1,
+     290,   291,    -1,    -1,    -1,    -1,    -1,    -1,   298,    -1,
+      -1,    -1,    -1,    -1,    -1,    51,    -1,    53,    54,    55,
+      56,    -1,    -1,   343,    -1,    -1,   511,    -1,   348,   349,
+      -1,    -1,    -1,    69,    -1,   520,    72,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   367,    84,   534,
+      -1,   536,    -1,   343,    -1,    -1,    -1,    93,   348,   349,
+     545,    -1,    -1,    99,   100,   101,    -1,   387,    -1,    -1,
+      -1,    -1,   392,   393,    -1,    -1,    -1,   367,    -1,    -1,
+    1008,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     126,   411,    -1,   129,    -1,    -1,    -1,   387,    -1,    -1,
+      -1,    -1,   392,    -1,    -1,   395,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   599,    -1,    -1,    -1,    -1,    -1,
+      -1,   411,    -1,    -1,    -1,     2,    -1,     4,    -1,    -1,
+      -1,    -1,   452,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   461,    -1,    -1,    -1,   435,   436,    -1,    -1,   469,
+      -1,    72,    73,    74,    75,    76,    77,    78,    79,   479,
+      81,    82,   452,    -1,    -1,    -1,    87,    88,    -1,    -1,
+      -1,   461,    -1,    50,    -1,    -1,    -1,    -1,    -1,   469,
+      -1,    -1,   667,    -1,    -1,    -1,    -1,    -1,    -1,   479,
+      -1,   511,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     520,   122,   123,   124,   125,   126,   127,   128,   129,   130,
+     131,    -1,    -1,    -1,   534,    -1,   536,    -1,    -1,    -1,
+      -1,   511,    -1,    -1,    -1,   545,    -1,    -1,    -1,    -1,
+     520,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   118,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   545,    -1,    -1,    -1,    -1,
+      -1,    -1,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    -1,    -1,    87,    88,   599,
+      -1,    -1,    -1,    -1,   769,    -1,    -1,    -1,    -1,    -1,
+      -1,   776,   777,   778,    -1,    -1,    -1,    -1,    -1,   784,
+      -1,    -1,    -1,    -1,   789,   790,    -1,    -1,    -1,    -1,
+     795,   796,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,    -1,    -1,   809,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   209,    -1,    -1,    -1,   821,   822,    -1,    -1,
+      -1,    -1,    -1,    -1,   829,    -1,    -1,   667,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   840,   841,    44,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   848,    -1,    -1,    -1,    -1,    -1,    -1,
-      89,    -1,    -1,   858,   859,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   867,    -1,   103,    -1,   871,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   113,   623,    -1,   116,   117,    -1,
-      -1,    -1,    -1,   722,    -1,    -1,    -1,    -1,    -1,    -1,
-     729,   730,    -1,    -1,    -1,    -1,    -1,   136,   137,    -1,
-      -1,    -1,    -1,   142,   143,   144,   145,   146,    -1,   748,
-     749,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   758,
-      -1,    -1,    -1,    -1,    -1,   930,   765,    -1,    -1,    -1,
-      -1,   936,    -1,   938,    -1,    -1,   941,    -1,   777,   778,
-      -1,    -1,    -1,    -1,    -1,    -1,   785,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   667,   863,    -1,
+      -1,    -1,    -1,   868,    -1,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    -1,    -1,
+      87,    88,    -1,    -1,    -1,    -1,   891,    -1,   285,    -1,
+      -1,    -1,    -1,   290,   291,    -1,   901,   902,    -1,    -1,
+     905,   298,    -1,    -1,   909,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   120,    -1,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,    -1,    -1,    -1,    -1,   769,
+      -1,    -1,    -1,   140,    -1,    -1,   776,   777,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   343,    -1,    -1,    -1,
+      -1,   348,    -1,    -1,    -1,   795,   796,    -1,    -1,   769,
+     965,    -1,   967,    -1,    -1,   970,    -1,   777,   778,   809,
+     367,    -1,    -1,    -1,   784,    -1,    -1,    -1,    -1,   789,
+     790,   821,   822,    -1,    -1,   795,   796,    -1,    -1,   829,
+     387,    -1,    -1,    -1,    -1,   392,    -1,    -1,   395,   809,
+     840,   841,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   821,   822,    -1,    -1,    -1,    -1,    -1,    -1,   829,
+      -1,    -1,    -1,   863,    -1,    -1,    -1,    -1,   868,    -1,
+     840,   841,    -1,    -1,    -1,    -1,    -1,    -1,   435,   436,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   800,   801,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   722,    -1,    -1,    -1,    -1,    -1,
-      -1,   820,   730,   731,    -1,    -1,   825,    -1,    -1,   737,
-      -1,    -1,    -1,    -1,   742,   743,    -1,    -1,    -1,    -1,
-     748,   749,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     758,    -1,    -1,    -1,    -1,    -1,    -1,   765,    -1,   858,
-     859,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   867,   777,
-     778,    -1,   871,    -1,    -1,    -1,    -1,   785,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    44,    -1,    -1,    -1,
-      -1,    -1,   800,   801,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   452,    -1,    -1,    -1,    -1,
+      -1,   901,   902,    -1,   461,   905,    -1,    -1,    -1,   909,
+      -1,    -1,   469,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   891,   479,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   901,   902,    -1,    -1,   905,    -1,    -1,    -1,   909,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    72,    73,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    -1,    -1,    87,
-      88,   930,    -1,    -1,    -1,    -1,    -1,   936,    -1,   938,
-     848,    -1,   941,    72,    73,    74,    75,    76,    77,    78,
-     858,   859,    81,    82,    -1,    -1,    -1,    -1,    87,    88,
-      -1,    -1,   120,   871,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   140,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   511,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   520,    -1,   965,    -1,   967,    -1,    -1,
+     970,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   545,    -1,
+      -1,    -1,    -1,    -1,    -1,   965,    -1,   967,    -1,    -1,
+     970,    -1,    -1,    -1,    -1,    -1,    -1,     0,     1,    -1,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      -1,    -1,    -1,    -1,    -1,    -1,    19,    -1,    21,    22,
+      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   930,    -1,    -1,    -1,    -1,    -1,   936,    -1,
-     938,     0,     1,   941,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    -1,    -1,    -1,    -1,    -1,    -1,
-      19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
-      -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
-      39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    -1,    58,
-      59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,
-      69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    99,    -1,    -1,   102,
+     667,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
+     113,    -1,    -1,   116,   117,    -1,    -1,    72,    73,    74,
+      75,    76,    77,    78,    -1,    -1,    81,    82,    -1,   132,
+     133,   134,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   144,    -1,   146,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    44,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,    -1,    -1,    -1,
+      -1,    -1,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    -1,    -1,    87,    88,    -1,
+      -1,    -1,   769,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     777,   778,    -1,    -1,    -1,    -1,    -1,   784,    -1,    -1,
+      -1,    -1,   789,   790,    -1,    -1,    -1,    -1,   795,   796,
+     120,    -1,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,   809,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   821,   822,    -1,    -1,    -1,    -1,
+      -1,    -1,   829,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   840,   841,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,     0,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,
-      99,    -1,    -1,   102,    -1,   104,   105,   106,   107,   108,
-     109,     0,    -1,   112,   113,    -1,    -1,   116,   117,    -1,
-      -1,    -1,    -1,    -1,    13,    14,    15,    16,    17,    18,
-      -1,    20,    -1,   132,   133,   134,    -1,    -1,    27,    28,
-      -1,    -1,    -1,    -1,    -1,   144,    -1,   146,    37,    38,
-      -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,
+      -1,    13,    14,    15,    16,    17,    18,    -1,    20,    -1,
+      -1,    -1,    -1,    -1,    -1,    27,    28,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   891,    37,    38,    -1,    40,    41,
+      42,    43,    44,    -1,   901,   902,    -1,    -1,    -1,    -1,
+      -1,    -1,   909,    -1,    -1,    57,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    -1,    -1,    87,    88,
-      89,    -1,    91,    92,    -1,    -1,    -1,    -1,    -1,    98,
-      -1,    -1,    -1,    -1,   103,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   113,    -1,    -1,   116,   117,    -1,
-     119,   120,    -1,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,    -1,    -1,     0,    -1,    -1,   137,   138,
-     139,   140,    -1,    -1,   143,   144,   145,   146,    13,    14,
-      15,    16,    17,    18,    -1,    20,    -1,    -1,    -1,    -1,
-      -1,    -1,    27,    28,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    37,    38,    -1,    40,    41,    42,    43,    44,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    -1,    -1,    87,    88,    89,    -1,    91,
+      92,    -1,    -1,    -1,    -1,    -1,    98,    -1,    -1,    -1,
+      -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,   965,    -1,
+     967,   113,    -1,   970,   116,   117,    -1,   119,   120,    -1,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+      -1,    -1,     0,    -1,    -1,   137,   138,   139,   140,    -1,
+      -1,   143,   144,   145,   146,    13,    14,    15,    16,    17,
+      18,    -1,    20,    -1,    -1,    -1,    -1,    -1,    -1,    27,
+      28,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,
+      38,    -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    72,    73,    74,
-      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      -1,    -1,    87,    88,    89,    -1,    -1,    92,    -1,    -1,
-      -1,    -1,    -1,    98,    -1,    -1,    -1,    -1,   103,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   113,    -1,
-      -1,   116,   117,    -1,    -1,   120,    -1,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,    -1,    -1,     0,
-      -1,    -1,   137,   138,   139,   140,    -1,   142,   143,   144,
-     145,   146,    13,    14,    15,    -1,    17,    18,    -1,    20,
-      -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,
-      41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    72,    73,    74,    75,    76,    77,
+      78,    79,    80,    81,    82,    83,    84,    -1,    -1,    87,
+      88,    89,    -1,    -1,    92,    -1,    -1,    -1,    -1,    -1,
+      98,    -1,    -1,    -1,    -1,   103,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   113,    -1,    -1,   116,   117,
+      -1,    -1,   120,    -1,   122,   123,   124,   125,   126,   127,
+     128,   129,   130,   131,    -1,    -1,     0,    -1,    -1,   137,
+     138,   139,   140,    -1,   142,   143,   144,   145,   146,    13,
+      14,    15,    -1,    17,    18,    -1,    20,    -1,    -1,    -1,
+      -1,    -1,    26,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,    43,
+      44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    -1,    -1,    87,    88,    89,    -1,    91,    92,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   103,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   113,
+      -1,    -1,   116,   117,    -1,   119,   120,    -1,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,    -1,    -1,
+       0,    -1,   136,   137,   138,    -1,   140,    -1,    -1,   143,
+     144,   145,   146,    13,    14,    15,    -1,    17,    18,    -1,
+      20,    -1,    -1,    -1,    -1,    -1,    26,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    -1,
+      40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    72,    73,    74,    75,    76,    77,    78,    79,    80,
-      81,    82,    83,    84,    -1,    -1,    87,    88,    89,    -1,
-      91,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   113,    -1,    -1,   116,   117,    -1,   119,   120,
-      -1,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,    -1,    -1,     0,    -1,   136,   137,   138,    -1,   140,
-      -1,    -1,   143,   144,   145,   146,    13,    14,    15,    -1,
-      17,    18,    -1,    20,    -1,    -1,    -1,    -1,    -1,    26,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      37,    38,    -1,    40,    41,    42,    43,    44,    -1,    -1,
+      -1,    -1,    72,    73,    74,    75,    76,    77,    78,    79,
+      80,    81,    82,    83,    84,    -1,    -1,    87,    88,    89,
+      -1,    91,    92,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   113,    -1,    -1,   116,   117,    -1,   119,
+     120,    -1,   122,   123,   124,   125,   126,   127,   128,   129,
+     130,   131,    -1,    -1,     0,    -1,   136,   137,   138,    -1,
+     140,    -1,    -1,   143,   144,   145,   146,    13,    14,    15,
+      -1,    17,    18,    -1,    20,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    37,    38,    -1,    40,    41,    42,    43,    44,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    -1,    -1,
-      87,    88,    89,    -1,    91,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   103,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   113,    -1,    -1,   116,
-     117,    -1,   119,   120,    -1,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,   131,    -1,    -1,     0,    -1,   136,
-     137,   138,    -1,   140,    -1,    -1,   143,   144,   145,   146,
-      13,    14,    15,    -1,    17,    18,    -1,    20,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,    42,
-      43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    -1,
+      -1,    87,    88,    89,    -1,    91,    92,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   103,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   113,    -1,    -1,
+     116,   117,    -1,   119,   120,    -1,   122,   123,   124,   125,
+     126,   127,   128,   129,   130,   131,    -1,    -1,     0,    -1,
+      -1,   137,   138,    -1,   140,    -1,    -1,   143,   144,   145,
+     146,    13,    14,    15,    -1,    17,    18,    -1,    20,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    72,
-      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    -1,    -1,    87,    88,    89,    -1,    91,    -1,
+      -1,    -1,    -1,    -1,    -1,    37,    38,    -1,    40,    41,
+      42,    43,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     113,    -1,    -1,   116,   117,    -1,   119,   120,    -1,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,    -1,
-      -1,     0,    -1,    -1,   137,   138,    -1,   140,    -1,    -1,
-     143,   144,   145,   146,    13,    14,    15,    -1,    17,    18,
-      -1,    20,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    37,    38,
-      -1,    40,    41,    42,    43,    44,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+      82,    83,    84,    -1,    -1,    87,    88,    89,    -1,    91,
+      92,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   103,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   113,    -1,    -1,   116,   117,    -1,   119,   120,    -1,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+      -1,    -1,    -1,    -1,    -1,   137,   138,    -1,   140,    -1,
+      -1,   143,   144,   145,   146,     1,    -1,     3,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      -1,    -1,    18,    19,    -1,    21,    22,    23,    24,    -1,
+      -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
+      36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
+      -1,    47,    48,    49,    50,    51,    52,    53,    54,    55,
+      56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,
+      66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    -1,    -1,    87,    88,
-      89,    -1,    91,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   103,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   113,    -1,    -1,   116,   117,    -1,
-     119,   120,    -1,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,    -1,    -1,    -1,    -1,    -1,   137,   138,
-      -1,   140,    -1,    -1,   143,   144,   145,   146,     1,    -1,
-       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      13,    14,    15,    -1,    -1,    18,    19,    -1,    21,    22,
-      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
-      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
-      -1,    -1,    45,    -1,    47,    48,    49,    50,    51,    52,
-      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
-      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
+      -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,
+      96,    97,    -1,    99,    -1,    -1,   102,    -1,   104,   105,
+     106,   107,   108,   109,    -1,    -1,   112,   113,    -1,    -1,
+     116,   117,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   132,   133,   134,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   144,     1,
+     146,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    -1,    -1,    15,    -1,    17,    18,    19,    -1,    21,
+      22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
+      32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
+      -1,    -1,    -1,    45,    -1,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    -1,    58,    59,    60,    -1,
+      -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,    71,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
-      93,    94,    -1,    96,    97,    -1,    99,    -1,    -1,   102,
-      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
-     113,    -1,    -1,   116,   117,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   132,
-     133,   134,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   144,     1,   146,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    -1,    -1,    15,    -1,    17,    18,
-      19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
-      -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
-      39,    -1,    -1,    -1,    -1,    -1,    45,    -1,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    -1,    58,
-      59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,
-      69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,
+      -1,    93,    94,    -1,    96,    97,    -1,    99,    -1,    -1,
+     102,    -1,   104,   105,   106,   107,   108,   109,    -1,    -1,
+     112,   113,    -1,    -1,   116,   117,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,
-      99,    -1,    -1,   102,    -1,   104,   105,   106,   107,   108,
-     109,    -1,    -1,   112,   113,    -1,    -1,   116,   117,    -1,
+     132,   133,   134,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   144,     1,   146,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    -1,    -1,    15,    -1,    -1,
+      18,    19,    20,    21,    22,    23,    24,    -1,    -1,    -1,
+      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
+      -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    -1,    47,
+      48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
+      58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,
+      -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   132,   133,   134,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   144,     1,   146,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    -1,    -1,
-      15,    -1,    -1,    18,    19,    20,    21,    22,    23,    24,
-      -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
-      35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
-      45,    -1,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,
-      -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,
+      -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,
+      -1,    99,    -1,    -1,   102,    -1,   104,   105,   106,   107,
+     108,   109,    -1,    -1,   112,   113,    -1,    -1,   116,   117,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,
-      -1,    96,    97,    -1,    99,    -1,    -1,   102,    -1,   104,
-     105,   106,   107,   108,   109,    -1,    -1,   112,   113,    -1,
-      -1,   116,   117,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   132,   133,   134,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   144,
-       1,   146,     3,     4,     5,     6,     7,     8,     9,    10,
-      11,    12,    -1,    -1,    15,    -1,    -1,    18,    19,    -1,
-      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
-      31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
-      -1,    -1,    -1,    -1,    45,    -1,    47,    48,    49,    50,
-      51,    52,    53,    54,    55,    56,    -1,    58,    59,    60,
-      -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,
-      71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
-      -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,    -1,
-      -1,   102,    -1,   104,   105,   106,   107,   108,   109,    -1,
-      -1,   112,   113,    -1,    -1,   116,   117,     1,    -1,     3,
+      -1,    -1,    -1,    -1,   132,   133,   134,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   144,     1,   146,     3,
        4,     5,     6,     7,     8,     9,    10,    11,    12,    -1,
-      -1,   132,   133,   134,    -1,    19,    -1,    21,    22,    23,
-      24,    -1,    -1,   144,    -1,   146,    30,    31,    32,    33,
+      -1,    15,    -1,    -1,    18,    19,    -1,    21,    22,    23,
+      24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    45,    46,    47,    48,    49,    50,    51,    52,    53,
+      -1,    45,    -1,    47,    48,    49,    50,    51,    52,    53,
       54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
       -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,
       94,    -1,    96,    97,    -1,    99,    -1,    -1,   102,    -1,
      104,   105,   106,   107,   108,   109,    -1,    -1,   112,   113,
-      -1,    -1,   116,   117,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   132,   133,
-     134,    -1,    -1,   137,    -1,    -1,    -1,    -1,    -1,    -1,
-     144,     1,   146,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    -1,    14,    15,    -1,    -1,    -1,    19,
-      -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    45,    -1,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
-      70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   116,   117,     1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    12,    -1,    -1,   132,   133,
+     134,    -1,    19,    -1,    21,    22,    23,    24,    -1,    -1,
+     144,    -1,   146,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,
+      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,
+      67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,
-      -1,    -1,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,   113,    -1,    -1,   116,   117,     1,    -1,
+      -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,
+      97,    -1,    99,    -1,    -1,   102,    -1,   104,   105,   106,
+     107,   108,   109,    -1,    -1,   112,   113,    -1,    -1,   116,
+     117,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   132,   133,   134,    -1,    -1,
+     137,    -1,    -1,    -1,    -1,    -1,    -1,   144,     1,   146,
        3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
-      -1,    -1,   132,   133,   134,    -1,    19,    -1,    21,    22,
-      23,    24,    -1,    -1,   144,    -1,   146,    30,    31,    32,
+      -1,    14,    15,    -1,    -1,    -1,    19,    -1,    21,    22,
+      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
       33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
       -1,    -1,    45,    -1,    47,    48,    49,    50,    51,    52,
       53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
@@ -4003,7 +4102,7 @@ static const yytype_int16 yycheck[] =
      113,    -1,    -1,   116,   117,     1,    -1,     3,     4,     5,
        6,     7,     8,     9,    10,    11,    12,    -1,    -1,   132,
      133,   134,    -1,    19,    -1,    21,    22,    23,    24,    -1,
-     143,   144,    -1,   146,    30,    31,    32,    33,    34,    35,
+      -1,   144,    -1,   146,    30,    31,    32,    33,    34,    35,
       36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
       -1,    47,    48,    49,    50,    51,    52,    53,    54,    55,
       56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,
@@ -4023,26 +4122,26 @@ static const yytype_int16 yycheck[] =
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,
       99,    -1,    -1,   102,    -1,   104,   105,   106,   107,   108,
-     109,    -1,    -1,   112,   113,    -1,    -1,   116,   117,    -1,
+     109,    -1,    -1,   112,   113,    -1,    -1,   116,   117,     1,
+      -1,     3,     4,     5,     6,     7,     8,     9,    10,    11,
+      12,    -1,    -1,   132,   133,   134,    -1,    19,    -1,    21,
+      22,    23,    24,    -1,   143,   144,    -1,   146,    30,    31,
+      32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
+      -1,    -1,    -1,    45,    -1,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    -1,    58,    59,    60,    -1,
+      -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,    71,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   132,   133,   134,    -1,    -1,   137,    -1,
-      -1,    -1,    -1,    -1,    -1,   144,     1,   146,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    -1,    -1,
-      15,    -1,    -1,    -1,    19,    -1,    21,    22,    23,    24,
-      -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
-      35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
-      45,    -1,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,
-      -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,
+      -1,    93,    94,    -1,    96,    97,    -1,    99,    -1,    -1,
+     102,    -1,   104,   105,   106,   107,   108,   109,    -1,    -1,
+     112,   113,    -1,    -1,   116,   117,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,
-      -1,    96,    97,    -1,    99,    -1,    -1,   102,    -1,   104,
-     105,   106,   107,   108,   109,    -1,    -1,   112,   113,    -1,
-      -1,   116,   117,    -1,    -1,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    -1,    -1,   132,   133,   134,
-      -1,    19,    -1,    21,    22,    23,    24,    -1,    -1,   144,
-      -1,   146,    30,    31,    32,    33,    34,    35,    36,    -1,
-      -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
+     132,   133,   134,    -1,    -1,   137,    -1,    -1,    -1,    -1,
+      -1,    -1,   144,     1,   146,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    -1,    -1,    15,    -1,    -1,
+      -1,    19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,
+      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
+      -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    -1,    47,
       48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
       58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,
       -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,
@@ -4054,7 +4153,7 @@ static const yytype_int16 yycheck[] =
       11,    12,    -1,    -1,   132,   133,   134,    -1,    19,    -1,
       21,    22,    23,    24,    -1,    -1,   144,    -1,   146,    30,
       31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
-      -1,    -1,    -1,    -1,    45,    -1,    47,    48,    49,    50,
+      -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
       51,    52,    53,    54,    55,    56,    -1,    58,    59,    60,
       -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,
       71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
@@ -4062,88 +4161,88 @@ static const yytype_int16 yycheck[] =
       -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,    -1,
       -1,   102,    -1,   104,   105,   106,   107,   108,   109,    -1,
       -1,   112,   113,    -1,    -1,   116,   117,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    -1,    -1,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    -1,
       -1,   132,   133,   134,    -1,    19,    -1,    21,    22,    23,
       24,    -1,    -1,   144,    -1,   146,    30,    31,    32,    33,
       34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,    53,
+      -1,    45,    -1,    47,    48,    49,    50,    51,    52,    53,
       54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
       -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,
-      94,    -1,    96,    97,    -1,    -1,    -1,    -1,   102,    -1,
+      94,    -1,    96,    97,    -1,    99,    -1,    -1,   102,    -1,
      104,   105,   106,   107,   108,   109,    -1,    -1,   112,   113,
-      -1,    -1,   116,   117,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   132,   133,
-     134,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     144,    -1,   146,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    -1,
-      -1,    81,    82,    -1,    -1,    85,    86,    87,    88,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,
-     100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   116,   117,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    -1,    -1,    -1,   132,   133,
+     134,    -1,    19,    -1,    21,    22,    23,    24,    -1,    -1,
+     144,    -1,   146,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,
+      67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,    -1,   133,   134,    -1,    -1,    -1,    -1,    -1,
-      -1,   141,   142,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,
-      -1,    21,    22,    23,    24,    -1,    26,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
-      70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,
+      97,    -1,    -1,    -1,    -1,   102,    -1,   104,   105,   106,
+     107,   108,   109,    -1,    -1,   112,   113,    -1,    -1,   116,
+     117,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   132,   133,   134,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   144,    -1,   146,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,    -1,    -1,    -1,
+      -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,    -1,    -1,    81,    82,
+      -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,
-     100,   101,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,    -1,
+     133,   134,    -1,    -1,    -1,    -1,    -1,    -1,   141,   142,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    19,    -1,    21,    22,
+      23,    24,    -1,    26,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   132,   133,   134,    -1,   136,    -1,    -1,    -1,
-      -1,    -1,   142,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,
-      -1,    21,    22,    23,    24,    -1,    26,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
-      70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    99,   100,   101,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,
-     100,   101,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   132,
+     133,   134,    -1,   136,    -1,    -1,    -1,    -1,    -1,   142,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    19,    -1,    21,    22,
+      23,    24,    -1,    26,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   132,   133,   134,    -1,   136,    -1,    -1,    -1,
-      -1,    -1,   142,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,
-      -1,    21,    22,    23,    24,    -1,    26,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
-      70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    99,   100,   101,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,
-     100,   101,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    -1,    -1,
-      -1,    -1,   132,   133,   134,    19,   136,    21,    22,    23,
-      24,    -1,   142,    -1,    -1,    -1,    30,    31,    32,    33,
-      34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
-      -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   132,
+     133,   134,    -1,   136,    -1,    -1,    -1,    -1,    -1,   142,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    19,    -1,    21,    22,
+      23,    24,    -1,    26,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    90,    91,    -1,    93,
-      94,    -1,    96,    97,    -1,    99,   100,   101,   102,    -1,
-     104,   105,   106,   107,   108,   109,    -1,    -1,   112,    -1,
-      -1,    -1,    -1,    -1,    -1,   119,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    -1,    -1,    -1,   132,   133,
-     134,    -1,    19,    -1,    21,    22,    23,    24,   142,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    99,   100,   101,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
+      -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,
+     133,   134,    19,   136,    21,    22,    23,    24,    -1,   142,
       -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
       -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
@@ -4162,537 +4261,541 @@ static const yytype_int16 yycheck[] =
       60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
       70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,
+      90,    91,    -1,    93,    94,    -1,    96,    97,    -1,    99,
      100,   101,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    -1,    -1,
-      -1,    -1,   132,   133,   134,    19,    -1,    21,    22,    23,
-      24,    -1,   142,    -1,    -1,    -1,    30,    31,    32,    33,
-      34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
-      -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,
-      94,    -1,    96,    97,    -1,    99,   100,   101,   102,    -1,
-     104,   105,   106,   107,   108,   109,    -1,    -1,   112,    -1,
-      -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,   133,
-     134,    19,    -1,    21,    22,    23,    24,    -1,   142,    -1,
-      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
-      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
-      58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,
-      -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,
-      -1,    99,   100,   101,   102,    -1,   104,   105,   106,   107,
-     108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   132,   133,   134,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   142,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
-      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    37,
-      38,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
-      -1,    -1,    -1,    -1,    -1,    63,    -1,    -1,    -1,    -1,
-      -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    -1,    -1,    81,    82,    -1,    -1,    85,    86,    87,
-      88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     108,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,    -1,   133,   134,    -1,    -1,    -1,
-      -1,    -1,    -1,   141,     3,     4,     5,     6,     7,     8,
-       9,    10,    11,    12,    13,    14,    15,    16,    17,    18,
-      19,    20,    21,    22,    23,    24,    25,    26,    -1,    -1,
-      -1,    30,    31,    32,    33,    34,    35,    36,    37,    38,
-      39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,
-      49,    50,    51,    52,    53,    54,    55,    56,    -1,    -1,
-      -1,    -1,    -1,    -1,    63,    -1,    -1,    -1,    -1,    -1,
-      -1,    70,    71,    72,    73,    74,    75,    76,    77,    78,
-      -1,    -1,    81,    82,    -1,    -1,    85,    86,    87,    88,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      99,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,
+      -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,   119,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,   132,   133,   134,    -1,    19,    -1,    21,    22,
+      23,    24,   142,    -1,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,    -1,   133,   134,    -1,    -1,    -1,    -1,
-      -1,    -1,   141,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    25,    26,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
-      -1,    -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,
-      50,    51,    52,    -1,    -1,    55,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    99,   100,   101,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
+      -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,
+     133,   134,    19,    -1,    21,    22,    23,    24,    -1,   142,
+      -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,
+      67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    -1,
-      -1,    81,    82,    -1,    -1,    85,    86,    87,    88,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,
-     100,    -1,    -1,    -1,   104,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,
+      97,    -1,    99,   100,   101,   102,    -1,   104,   105,   106,
+     107,   108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,
+      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    -1,    -1,    -1,    -1,   132,   133,   134,    19,    -1,
+      21,    22,    23,    24,    -1,   142,    -1,    -1,    -1,    30,
+      31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,
+      51,    52,    53,    54,    55,    56,    -1,    58,    59,    60,
+      -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,
+      71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
+      -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,   100,
+     101,   102,    -1,   104,   105,   106,   107,   108,   109,    -1,
+      -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,    -1,   133,   134,    -1,    -1,    -1,    -1,    -1,
-      -1,   141,     3,     4,     5,     6,     7,     8,     9,    10,
+      -1,   132,   133,   134,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   142,     3,     4,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
       21,    22,    23,    24,    25,    26,    -1,    -1,    -1,    30,
       31,    32,    33,    34,    35,    36,    37,    38,    39,    -1,
       -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
-      51,    52,    -1,    -1,    55,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
+      51,    52,    53,    54,    55,    56,    -1,    -1,    -1,    -1,
+      -1,    -1,    63,    -1,    -1,    -1,    -1,    -1,    -1,    70,
       71,    72,    73,    74,    75,    76,    77,    78,    -1,    -1,
       81,    82,    -1,    -1,    85,    86,    87,    88,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,   100,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,   122,   123,   124,   125,   126,   127,   128,   129,   130,
      131,    -1,   133,   134,    -1,    -1,    -1,    -1,    -1,    -1,
      141,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,    -1,    21,
-      22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
-      32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    -1,    58,    59,    60,    -1,
-      -1,    63,    -1,    -1,    66,    67,    -1,    69,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,
-      -1,    93,    94,    -1,    96,    97,    -1,    -1,    -1,    -1,
-     102,    -1,   104,   105,   106,   107,   108,   109,    -1,    -1,
-     112,    -1,    -1,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,
-     132,    21,    22,    23,    24,    -1,    -1,    -1,   140,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    -1,
-      -1,    -1,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    -1,    -1,    -1,    -1,    -1,
-      -1,    19,   132,    21,    22,    23,    24,    -1,    -1,    -1,
-     140,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
-      -1,    39,    -1,    -1,    -1,    -1,    -1,    45,    46,    47,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
-      58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,
-      -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,
-      -1,    99,    -1,    -1,   102,    -1,   104,   105,   106,   107,
-     108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,
-      -1,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      -1,    -1,    -1,    -1,   132,   133,   134,    19,    -1,    21,
-      22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
-      32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    -1,    58,    59,    60,    -1,
-      -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,    71,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    84,    -1,    -1,    -1,    -1,    -1,    90,    -1,
-      -1,    93,    94,    -1,    96,    97,    -1,    99,   100,   101,
-     102,    -1,   104,   105,   106,   107,   108,   109,    -1,    -1,
-     112,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    12,    -1,    -1,    -1,
-     132,   133,   134,    19,    -1,    21,    22,    23,    24,    -1,
-      -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
-      36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    45,
-      -1,    47,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,
-      66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,
+      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    26,    -1,    -1,    -1,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    -1,    -1,
+      -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    -1,    -1,    -1,    -1,    -1,
+      -1,    63,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    -1,    -1,    81,
+      82,    -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   108,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,
-      96,    97,    -1,    99,    -1,    -1,   102,    -1,   104,   105,
-     106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,    -1,
-      -1,    -1,    -1,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    -1,    -1,    -1,    -1,   132,   133,   134,    19,
-      -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
-      70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+      -1,   133,   134,    -1,    -1,    -1,    -1,    -1,    -1,   141,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    37,    38,    39,    -1,    -1,    -1,
+      -1,    -1,    45,    46,    47,    48,    49,    50,    51,    52,
+      -1,    -1,    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,    -1,    -1,    81,    82,
+      -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,
+      -1,   104,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,    -1,
+     133,   134,    -1,    -1,    -1,    -1,    -1,    -1,   141,     3,
+       4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    -1,    -1,    -1,    30,    31,    32,    33,
+      34,    35,    36,    37,    38,    39,    -1,    -1,    -1,    -1,
+      -1,    45,    46,    47,    48,    49,    50,    51,    52,    -1,
+      -1,    55,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
+      74,    75,    76,    77,    78,    -1,    -1,    81,    82,    -1,
+      -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,
-     100,   101,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    -1,    -1,
-      -1,    -1,   132,   133,   134,    19,    -1,    21,    22,    23,
-      24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
-      34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
-      -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,    -1,   133,
+     134,    -1,    -1,    -1,    -1,    -1,    -1,   141,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    19,    -1,    21,    22,    23,    24,
+      -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
+      35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,
+      -1,    66,    67,    -1,    69,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,
-      94,    -1,    96,    97,    -1,    99,   100,   101,   102,    -1,
-     104,   105,   106,   107,   108,   109,    -1,    -1,   112,    -1,
-      -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,   133,
-     134,    19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,
-      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
-      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
-      58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,
-      -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,
+      -1,    96,    97,    -1,    -1,    -1,    -1,   102,    -1,   104,
+     105,   106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    19,   132,    21,    22,
+      23,    24,    -1,    -1,    -1,   140,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,
-      -1,    99,   100,    -1,   102,    -1,   104,   105,   106,   107,
-     108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,
-      -1,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      -1,    -1,    -1,    -1,   132,   133,   134,    19,    -1,    21,
-      22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
-      32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    -1,    58,    59,    60,    -1,
-      -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,    71,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    -1,    -1,    -1,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
+      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    12,    -1,    -1,    -1,    -1,    -1,    -1,    19,   132,
+      21,    22,    23,    24,    -1,    -1,    -1,   140,    -1,    30,
+      31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
+      -1,    -1,    -1,    -1,    45,    46,    47,    48,    49,    50,
+      51,    52,    53,    54,    55,    56,    -1,    58,    59,    60,
+      -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,
+      71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
+      -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,    -1,
+      -1,   102,    -1,   104,   105,   106,   107,   108,   109,    -1,
+      -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    -1,    -1,    -1,
+      -1,   132,   133,   134,    19,    -1,    21,    22,    23,    24,
+      -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
+      35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,
+      -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    84,
+      -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,
+      -1,    96,    97,    -1,    99,   100,   101,   102,    -1,   104,
+     105,   106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,
+      -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    12,    -1,    -1,    -1,   132,   133,   134,
+      19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
+      -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
+      39,    -1,    -1,    -1,    -1,    -1,    45,    -1,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    -1,    58,
+      59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,
+      69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,
-      -1,    93,    94,    -1,    96,    97,    -1,    -1,   100,   101,
-     102,    -1,   104,   105,   106,   107,   108,   109,    -1,    -1,
-     112,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,
-     132,   133,   134,    19,    -1,    21,    22,    23,    24,    -1,
-      -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
-      36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,
-      66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,
+      -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,
+      99,    -1,    -1,   102,    -1,   104,   105,   106,   107,   108,
+     109,    -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,   132,   133,   134,    19,    -1,    21,    22,
+      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,
-      96,    97,    -1,    99,   100,    -1,   102,    -1,   104,   105,
-     106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,    -1,
-      -1,    -1,    -1,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    -1,    -1,    -1,    -1,   132,   133,   134,    19,
-      -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
-      70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    99,   100,   101,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
+      -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,
+     133,   134,    19,    -1,    21,    22,    23,    24,    -1,    -1,
+      -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,
+      67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    -1,
-     100,    -1,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    -1,    -1,
-      -1,    -1,   132,   133,   134,    19,    -1,    21,    22,    23,
-      24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
-      34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
-      -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,
+      -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,
+      97,    -1,    99,   100,   101,   102,    -1,   104,   105,   106,
+     107,   108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,
+      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    -1,    -1,    -1,    -1,   132,   133,   134,    19,    -1,
+      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
+      31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,
+      51,    52,    53,    54,    55,    56,    -1,    58,    59,    60,
+      -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,
+      71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
+      -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,   100,
+      -1,   102,    -1,   104,   105,   106,   107,   108,   109,    -1,
+      -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    -1,    -1,    -1,
+      -1,   132,   133,   134,    19,    -1,    21,    22,    23,    24,
+      -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
+      35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,
+      -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,
-      94,    -1,    96,    97,    -1,    99,    -1,    -1,   102,    -1,
-     104,   105,   106,   107,   108,   109,    -1,    -1,   112,    -1,
-      -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,   133,
-     134,    19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,
-      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
-      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
-      58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,
-      -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,
+      -1,    96,    97,    -1,    -1,   100,   101,   102,    -1,   104,
+     105,   106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,
+      -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    -1,    -1,    -1,    -1,   132,   133,   134,
+      19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
+      -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
+      39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    -1,    58,
+      59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,
+      69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,
-      -1,    99,    -1,    -1,   102,    -1,   104,   105,   106,   107,
-     108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,
-      -1,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      -1,    -1,    -1,    -1,   132,   133,   134,    19,    -1,    21,
-      22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
-      32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    -1,    58,    59,    60,    -1,
-      -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,    71,
+      -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,
+      99,   100,    -1,   102,    -1,   104,   105,   106,   107,   108,
+     109,    -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,   132,   133,   134,    19,    -1,    21,    22,
+      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,
-      -1,    93,    94,    -1,    96,    97,    -1,    99,    -1,    -1,
-     102,    -1,   104,   105,   106,   107,   108,   109,    -1,    -1,
-     112,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,
-     132,   133,   134,    19,    -1,    21,    22,    23,    24,    -1,
-      -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
-      36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,
-      66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    -1,   100,    -1,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
+      -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,
+     133,   134,    19,    -1,    21,    22,    23,    24,    -1,    -1,
+      -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,
+      67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,
-      96,    97,    -1,    99,    -1,    -1,   102,    -1,   104,   105,
-     106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,    -1,
-      -1,    -1,    -1,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    -1,    -1,    -1,    -1,   132,   133,   134,    19,
-      -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
-      70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,
+      97,    -1,    99,    -1,    -1,   102,    -1,   104,   105,   106,
+     107,   108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,
+      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    -1,    -1,    -1,    -1,   132,   133,   134,    19,    -1,
+      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
+      31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,
+      51,    52,    53,    54,    55,    56,    -1,    58,    59,    60,
+      -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,
+      71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
+      -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,    -1,
+      -1,   102,    -1,   104,   105,   106,   107,   108,   109,    -1,
+      -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    -1,    -1,    -1,
+      -1,   132,   133,   134,    19,    -1,    21,    22,    23,    24,
+      -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
+      35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,
+      -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    99,
-      -1,    -1,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    -1,    -1,
-      -1,    -1,   132,   133,   134,    19,    -1,    21,    22,    23,
-      24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
-      34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
-      -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,
+      -1,    96,    97,    -1,    99,    -1,    -1,   102,    -1,   104,
+     105,   106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,
+      -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    -1,    -1,    -1,    -1,   132,   133,   134,
+      19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
+      -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
+      39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    -1,    58,
+      59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,
+      69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,
-      94,    -1,    96,    97,    -1,    -1,    -1,    -1,   102,    -1,
-     104,   105,   106,   107,   108,   109,    -1,    -1,   112,    -1,
-      -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,   133,
-     134,    19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,
-      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
-      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
-      58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,
-      -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,
+      99,    -1,    -1,   102,    -1,   104,   105,   106,   107,   108,
+     109,    -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,   132,   133,   134,    19,    -1,    21,    22,
+      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    70,    71,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,
-      -1,    -1,    -1,    -1,   102,    -1,   104,   105,   106,   107,
-     108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,    -1,
-      -1,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      -1,    -1,    -1,    -1,   132,   133,   134,    19,    -1,    21,
-      22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
-      32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    -1,    58,    59,    60,    -1,
-      -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,    71,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    99,    -1,    -1,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
+      -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,   132,
+     133,   134,    19,    -1,    21,    22,    23,    24,    -1,    -1,
+      -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,
+      67,    -1,    69,    70,    71,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,
-      -1,    93,    94,    -1,    96,    97,    -1,    -1,    -1,    -1,
-     102,    -1,   104,   105,   106,   107,   108,   109,    -1,    -1,
-     112,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,
-     132,   133,   134,    19,    -1,    21,    22,    23,    24,    -1,
-      -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
-      36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,
-      66,    67,    -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,
+      97,    -1,    -1,    -1,    -1,   102,    -1,   104,   105,   106,
+     107,   108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,
+      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    -1,    -1,    -1,    -1,   132,   133,   134,    19,    -1,
+      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
+      31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,
+      51,    52,    53,    54,    55,    56,    -1,    58,    59,    60,
+      -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,    70,
+      71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
+      -1,    -1,    93,    94,    -1,    96,    97,    -1,    -1,    -1,
+      -1,   102,    -1,   104,   105,   106,   107,   108,   109,    -1,
+      -1,   112,    -1,    -1,    -1,    -1,    -1,    -1,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    -1,    -1,    -1,
+      -1,   132,   133,   134,    19,    -1,    21,    22,    23,    24,
+      -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
+      35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,
+      -1,    66,    67,    -1,    69,    70,    71,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    87,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,
-      96,    97,    -1,    -1,    -1,    -1,   102,    -1,   104,   105,
-     106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    19,   132,    21,    22,    23,
-      24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
-      34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
-      -1,    -1,    66,    67,    -1,    69,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,
+      -1,    96,    97,    -1,    -1,    -1,    -1,   102,    -1,   104,
+     105,   106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,
+      -1,    -1,    -1,    -1,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    -1,    -1,    -1,    -1,   132,   133,   134,
+      19,    -1,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
+      -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
+      39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    -1,    58,
+      59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,
+      69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    87,    -1,
+      -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,
+      -1,    -1,    -1,   102,    -1,   104,   105,   106,   107,   108,
+     109,    -1,    -1,   112,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    19,   132,    21,    22,    23,    24,    -1,    -1,
+      -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,
+      67,    -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,
-      94,    -1,    96,    97,    -1,    99,    -1,    -1,   102,    -1,
-     104,   105,   106,   107,   108,   109,    -1,    -1,   112,    -1,
-      -1,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,   132,    21,
-      22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,
-      32,    33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,
-      52,    53,    54,    55,    56,    -1,    58,    59,    60,    -1,
-      -1,    63,    -1,    -1,    66,    67,    -1,    69,    -1,    -1,
+      -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,
+      97,    -1,    99,    -1,    -1,   102,    -1,   104,   105,   106,
+     107,   108,   109,    -1,    -1,   112,    -1,    -1,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    19,   132,    21,    22,    23,    24,
+      -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,
+      35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    48,    49,    50,    51,    52,    53,    54,
+      55,    56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,
+      -1,    66,    67,    -1,    69,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,
-      -1,    93,    94,    -1,    96,    97,    -1,    99,    -1,    -1,
-     102,    -1,   104,   105,   106,   107,   108,   109,    -1,    -1,
-     112,    -1,    -1,     3,     4,     5,     6,     7,     8,     9,
-      10,    11,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,
-     132,    21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,
-      30,    31,    32,    33,    34,    35,    36,    -1,    -1,    39,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
-      50,    51,    52,    53,    54,    55,    56,    -1,    58,    59,
-      60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,
+      -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,
+      -1,    96,    97,    -1,    99,    -1,    -1,   102,    -1,   104,
+     105,   106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    19,   132,    21,    22,
+      23,    24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    -1,    58,    59,    60,    -1,    -1,
+      63,    -1,    -1,    66,    67,    -1,    69,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,
+      93,    94,    -1,    96,    97,    -1,    -1,    -1,    -1,   102,
+      -1,   104,   105,   106,   107,   108,   109,    -1,    -1,   112,
+      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
+      11,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    19,   132,
+      21,    22,    23,    24,    -1,    -1,    -1,    -1,    -1,    30,
+      31,    32,    33,    34,    35,    36,    -1,    -1,    39,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,    50,
+      51,    52,    53,    54,    55,    56,    -1,    58,    59,    60,
+      -1,    -1,    63,    -1,    -1,    66,    67,    -1,    69,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,    -1,
-      -1,    -1,   102,    -1,   104,   105,   106,   107,   108,   109,
-      -1,    -1,   112,    -1,    -1,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    19,   132,    21,    22,    23,    24,    -1,    -1,    -1,
-      -1,    -1,    30,    31,    32,    33,    34,    35,    36,    -1,
-      -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      48,    49,    50,    51,    52,    53,    54,    55,    56,    -1,
-      58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,
-      -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    90,
+      -1,    -1,    93,    94,    -1,    96,    97,    -1,    -1,    -1,
+      -1,   102,    -1,   104,   105,   106,   107,   108,   109,    -1,
+      -1,   112,    -1,    -1,     3,     4,     5,     6,     7,     8,
+       9,    10,    11,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      19,   132,    21,    22,    23,    24,    -1,    -1,    -1,    -1,
+      -1,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
+      39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    -1,    58,
+      59,    60,    -1,    -1,    63,    -1,    -1,    66,    67,    -1,
+      69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,
-      -1,    -1,    -1,    -1,   102,    -1,   104,   105,   106,   107,
-     108,   109,    -1,    -1,   112,    -1,    -1,     3,     4,     5,
-       6,     7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    19,   132,    21,    22,    23,    24,    -1,
-      -1,    -1,    -1,    -1,    30,    31,    32,    33,    34,    35,
-      36,    -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    48,    49,    50,    51,    52,    53,    54,    55,
-      56,    -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,
-      66,    67,    -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    90,    -1,    -1,    93,    94,    -1,    96,    97,    -1,
+      -1,    -1,    -1,   102,    -1,   104,   105,   106,   107,   108,
+     109,    -1,    -1,   112,    -1,    -1,     3,     4,     5,     6,
+       7,     8,     9,    10,    11,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    19,   132,    21,    22,    23,    24,    -1,    -1,
+      -1,    -1,    -1,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    39,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+      -1,    58,    59,    60,    -1,    -1,    63,    -1,    -1,    66,
+      67,    -1,    69,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,
-      96,    97,    -1,    -1,    -1,    -1,   102,    -1,   104,   105,
-     106,   107,   108,   109,    -1,    -1,   112,    -1,    -1,     3,
-       4,     5,     6,     7,     8,     9,    10,    11,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    19,   132,    21,    22,    23,
-      24,    -1,    -1,    -1,    -1,    -1,    30,    31,    32,    33,
-      34,    35,    36,    -1,    -1,    39,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    48,    49,    50,    51,    52,    53,
-      54,    55,    56,    -1,    58,    59,    60,    -1,    -1,    63,
-      -1,    -1,    66,    67,    -1,    69,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    90,    -1,    -1,    93,    94,    -1,    96,
+      97,    -1,    51,    52,    -1,   102,    55,   104,   105,   106,
+     107,   108,   109,    -1,    -1,   112,    -1,    -1,    -1,    -1,
+      -1,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      -1,    -1,    81,    82,    -1,   132,    85,    86,    87,    88,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    90,    -1,    -1,    93,
-      94,    -1,    96,    97,    -1,    51,    52,    -1,   102,    55,
-     104,   105,   106,   107,   108,   109,    -1,    -1,   112,    -1,
-      -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,    75,
-      76,    77,    78,    -1,    -1,    81,    82,    -1,   132,    85,
-      86,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    99,   100,    -1,    -1,    -1,    -1,    -1,
+      99,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,    -1,   133,   134,    51,
-      52,    -1,    -1,    55,    -1,   141,   142,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    -1,    -1,    81,
-      82,    -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,
+      -1,    -1,    -1,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,    -1,   133,   134,    51,    52,    -1,    -1,
+      55,    -1,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    -1,    -1,    81,    82,    -1,    -1,
+      85,    86,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    99,   100,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,    -1,   133,   134,
+      51,    52,    -1,    -1,    55,    -1,   141,   142,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
+      71,    72,    73,    74,    75,    76,    77,    78,    -1,    -1,
+      81,    82,    -1,    -1,    85,    86,    87,    88,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,   100,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-      -1,   133,   134,    51,    52,    -1,    -1,    55,    -1,   141,
-     142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    -1,    -1,    81,    82,    -1,    -1,    85,    86,    87,
-      88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,    -1,   133,   134,    51,    52,    -1,
-      -1,    55,    -1,   141,   142,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
-      74,    75,    76,    77,    78,    -1,    -1,    81,    82,    -1,
-      -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,    -1,
+      -1,   122,   123,   124,   125,   126,   127,   128,   129,   130,
+     131,    -1,   133,   134,    51,    52,    -1,    -1,    55,    -1,
+     141,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    -1,    -1,    81,    82,    -1,    -1,    85,    86,
+      87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,
-     124,   125,   126,   127,   128,   129,   130,   131,    -1,   133,
-     134,    51,    52,    -1,    -1,    55,    -1,   141,   142,    -1,
+      -1,    -1,    -1,    -1,    -1,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,    -1,   133,   134,    51,    52,
+      -1,    -1,    55,    -1,   141,   142,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,    -1,    -1,    81,    82,
+      -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    -1,
-      -1,    81,    82,    -1,    -1,    85,    86,    87,    88,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,
-     100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,    -1,
+     133,   134,    51,    52,    -1,    -1,    55,    -1,   141,   142,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,    -1,   133,   134,    51,    52,    -1,    -1,    55,
-      -1,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,    75,
-      76,    77,    78,    -1,    -1,    81,    82,    -1,    -1,    85,
-      86,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    99,   100,    -1,    -1,    -1,    -1,    -1,
+      -1,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      -1,    -1,    81,    82,    -1,    -1,    85,    86,    87,    88,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,    -1,   133,   134,    51,
-      52,    -1,    -1,    55,    -1,   141,   142,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    -1,    -1,    81,
-      82,    -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,
+      99,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,    -1,   133,   134,    51,    52,    -1,    -1,
+      55,    -1,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    -1,    -1,    81,    82,    -1,    -1,
+      85,    86,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    99,   100,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-      -1,   133,   134,    51,    52,    -1,    -1,    55,    -1,   141,
-     142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    -1,    -1,    81,    82,    -1,    -1,    85,    86,    87,
-      88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,    -1,   133,   134,
+      51,    52,    -1,    -1,    55,    -1,   141,   142,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
+      71,    72,    73,    74,    75,    76,    77,    78,    -1,    -1,
+      81,    82,    -1,    -1,    85,    86,    87,    88,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,   100,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,    -1,   133,   134,    51,    52,    -1,
-      -1,    55,    -1,   141,   142,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
-      74,    75,    76,    77,    78,    -1,    -1,    81,    82,    -1,
-      -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,
-     124,   125,   126,   127,   128,   129,   130,   131,    -1,   133,
-     134,    51,    52,    -1,    -1,    55,    -1,   141,   142,    -1,
+      -1,   122,   123,   124,   125,   126,   127,   128,   129,   130,
+     131,    -1,   133,   134,    51,    52,    -1,    -1,    55,    -1,
+     141,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    -1,    -1,    81,    82,    -1,    -1,    85,    86,
+      87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    -1,
-      -1,    81,    82,    -1,    -1,    85,    86,    87,    88,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,
-     100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,    -1,   133,   134,    51,    52,
+      -1,    -1,    55,    -1,   141,   142,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,    -1,    -1,    81,    82,
+      -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,    -1,   133,   134,    51,    52,    -1,    -1,    55,
-      -1,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,    75,
-      76,    77,    78,    -1,    -1,    81,    82,    -1,    -1,    85,
-      86,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    99,   100,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,    -1,
+     133,   134,    51,    52,    -1,    -1,    55,    -1,   141,   142,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,    -1,   133,   134,    51,
-      52,    -1,    -1,    55,    -1,   141,   142,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    -1,    -1,    81,
-      82,    -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,
+      -1,    70,    71,    72,    73,    74,    75,    76,    77,    78,
+      -1,    -1,    81,    82,    -1,    -1,    85,    86,    87,    88,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      99,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-      -1,   133,   134,    51,    52,    -1,    -1,    55,    -1,   141,
-     142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    -1,    -1,    81,    82,    -1,    -1,    85,    86,    87,
-      88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,    -1,   133,   134,    51,    52,    -1,    -1,
+      55,    -1,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    -1,    -1,    81,    82,    -1,    -1,
+      85,    86,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    99,   100,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   122,   123,   124,   125,   126,   127,
-     128,   129,   130,   131,    -1,   133,   134,    51,    52,    -1,
-      -1,    55,    -1,   141,   142,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,    73,
-      74,    75,    76,    77,    78,    -1,    -1,    81,    82,    -1,
-      -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,    -1,   133,   134,
+      51,    52,    -1,    -1,    55,    -1,   141,   142,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,
+      71,    72,    73,    74,    75,    76,    77,    78,    -1,    -1,
+      81,    82,    -1,    -1,    85,    86,    87,    88,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,   100,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,
-     124,   125,   126,   127,   128,   129,   130,   131,    -1,   133,
-     134,    51,    52,    -1,    -1,    55,    -1,   141,   142,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      70,    71,    72,    73,    74,    75,    76,    77,    78,    -1,
-      -1,    81,    82,    -1,    -1,    85,    86,    87,    88,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    99,
-     100,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   122,   123,   124,   125,   126,   127,   128,   129,   130,
+     131,    -1,   133,   134,    51,    52,    -1,    -1,    55,    -1,
+     141,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    -1,    -1,    81,    82,    -1,    -1,    85,    86,
+      87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    99,   100,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,   122,   123,   124,   125,   126,   127,   128,   129,
-     130,   131,    -1,   133,   134,    51,    52,    -1,    -1,    55,
-      -1,   141,   142,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    70,    71,    72,    73,    74,    75,
-      76,    77,    78,    -1,    -1,    81,    82,    -1,    -1,    85,
-      86,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    99,   100,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    44,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,    -1,   133,   134,    -1,
-      -1,    -1,    -1,    -1,    -1,   141,    72,    73,    74,    75,
-      76,    77,    78,    79,    80,    81,    82,    83,    84,    -1,
-      -1,    87,    88,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    -1,    -1,    87,    88,
+      -1,    -1,    -1,    -1,    -1,   122,   123,   124,   125,   126,
+     127,   128,   129,   130,   131,    -1,   133,   134,    51,    52,
+      -1,    -1,    55,    -1,   141,   142,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    70,    71,    72,
+      73,    74,    75,    76,    77,    78,    -1,    -1,    81,    82,
+      -1,    -1,    85,    86,    87,    88,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    99,   100,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   120,    -1,   122,   123,   124,   125,
-     126,   127,   128,   129,   130,   131,    -1,    -1,    -1,    -1,
-      -1,   120,    -1,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    -1,   146,    87,    88,
+      -1,    44,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,    44,
+     133,   134,    -1,    -1,    -1,    -1,    -1,    -1,   141,    72,
+      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
+      83,    84,    -1,    -1,    87,    88,    -1,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      -1,    -1,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,    -1,
+      -1,    -1,    -1,    -1,    -1,   120,    -1,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      -1,    -1,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    72,    73,    74,    75,    76,    77,    78,    79,
       80,    81,    82,    83,    84,    -1,    -1,    87,    88,    -1,
+      -1,    -1,    -1,    -1,    -1,   120,    -1,   122,   123,   124,
+     125,   126,   127,   128,   129,   130,   131,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   120,    -1,   122,   123,   124,   125,   126,   127,   128,
-     129,   130,   131,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     120,   140,   122,   123,   124,   125,   126,   127,   128,   129,
+     120,   146,   122,   123,   124,   125,   126,   127,   128,   129,
      130,   131,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
      140,    72,    73,    74,    75,    76,    77,    78,    79,    80,
       81,    82,    83,    84,    -1,    -1,    87,    88,    -1,    -1,
@@ -4704,27 +4807,27 @@ static const yytype_int16 yycheck[] =
      122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   140,    72,
       73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
-      83,    84,    -1,    -1,    87,    88,    -1,    -1,    -1,    92,
-      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    -1,    -1,    87,    88,    -1,    -1,    -1,
+      83,    84,    -1,    -1,    87,    88,    -1,    -1,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    -1,    -1,    87,    88,    -1,    -1,    -1,    92,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,    -1,   122,
      123,   124,   125,   126,   127,   128,   129,   130,   131,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,    -1,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
-      82,    83,    84,    -1,    -1,    87,    88,    72,    73,    74,
-      75,    76,    77,    78,    79,    -1,    81,    82,    -1,    -1,
-      -1,    -1,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131,    72,    73,    74,
-      75,    76,    77,    78,    -1,    -1,    81,    82,    -1,    -1,
-      -1,    -1,    87,    88,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   120,   140,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,    72,    73,
+      74,    75,    76,    77,    78,    79,    80,    81,    82,    83,
+      84,    -1,    -1,    87,    88,    -1,    -1,    -1,    92,    72,
+      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
+      83,    84,    -1,    -1,    87,    88,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   120,    -1,   122,   123,
+     124,   125,   126,   127,   128,   129,   130,   131,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   120,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,    72,
+      73,    74,    75,    76,    77,    78,    -1,    -1,    81,    82,
+      -1,    -1,    -1,    -1,    87,    88,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,   123,   124,
-     125,   126,   127,   128,   129,   130,   131
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131
 };
 
   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -4738,103 +4841,105 @@ static const yytype_int16 yystos[] =
       58,    59,    60,    63,    66,    67,    69,    70,    71,    90,
       93,    94,    96,    97,    99,   102,   104,   105,   106,   107,
      108,   109,   112,   132,   133,   134,   150,   151,   152,   157,
-     159,   161,   163,   164,   167,   168,   170,   171,   172,   174,
-     175,   184,   198,   219,   240,   241,   251,   252,   253,   257,
-     258,   259,   265,   266,   267,   269,   270,   271,   272,   273,
-     274,   309,   322,   152,    21,    22,    30,    31,    32,    39,
-      51,    55,    69,    87,    90,    93,   132,   176,   177,   198,
-     219,   271,   274,   309,   177,     3,     4,     5,     6,     7,
-       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,    23,    24,    25,    26,    30,
-      31,    32,    33,    34,    35,    36,    37,    38,    39,    45,
-      46,    47,    48,    49,    50,    51,    52,    55,    70,    71,
-      72,    73,    74,    75,    76,    77,    78,    81,    82,    85,
-      86,    87,    88,    99,   100,   122,   123,   124,   125,   126,
-     127,   128,   129,   130,   131,   133,   134,   141,   142,   178,
-     182,   183,   273,   303,   199,    90,   161,   162,   175,   219,
-     271,   272,   274,   162,   205,   207,    69,    90,   168,   175,
-     219,   224,   271,   274,    33,    34,    35,    36,    48,    49,
-      50,    51,    55,   104,   178,   179,   180,   267,   113,   116,
-     117,   144,   146,   162,   261,   262,   263,   315,   319,   320,
-     321,    51,    99,   100,   101,   133,   167,   184,   190,   193,
-     196,   253,   306,   308,   190,   190,   142,   187,   188,   191,
-     192,   322,   187,   191,   142,   316,   320,   179,   153,   136,
-     184,   219,   184,    55,     1,    93,   155,   156,   157,   169,
-     170,   322,   200,   202,   185,   196,   306,   322,   184,   305,
-     306,   322,    90,   140,   174,   219,   271,   274,   203,    53,
-      54,    56,    63,   108,   178,   268,    62,    64,    65,   114,
-     115,   254,   255,    63,   254,    63,   254,    63,   254,    61,
-     254,    58,    59,   163,   184,   184,   315,   321,    40,    41,
-      42,    43,    44,    37,    38,    28,   238,   119,   140,    93,
-      99,   171,   119,    72,    73,    74,    75,    76,    77,    78,
-      79,    80,    81,    82,    83,    84,    87,    88,   120,   122,
-     123,   124,   125,   126,   127,   128,   129,   130,   131,    89,
-     103,   138,   145,   313,    89,   313,   314,    26,   136,   242,
-     253,    91,    91,   187,   191,   242,   161,    51,    55,   176,
-      58,    59,   123,   275,    89,   138,   313,   214,   304,   215,
-      89,   145,   312,   154,   155,    55,    16,   220,   319,   119,
-      89,   138,   313,    91,    91,   220,   162,   162,    55,    89,
-     138,   313,    25,   108,   140,   264,   315,   113,   263,    20,
-     245,   319,    57,   307,   184,   184,   184,    92,   140,   194,
-     195,   322,   307,   194,   195,    84,   189,   190,   196,   306,
-     322,   190,   161,   315,   317,   161,   158,   136,   155,    89,
-     313,    91,   157,   169,   143,   315,   321,   317,   157,   317,
-     139,   195,   318,   321,   195,   318,   137,   318,    55,   171,
-     172,   173,   140,    89,   138,   313,    51,    53,    54,    55,
-      56,    69,    72,    93,    99,   100,   101,   126,   129,   142,
-     236,   278,   279,   282,   283,   284,   285,   287,   288,   289,
-     290,   292,   293,   294,   297,   298,   299,   300,   301,    63,
-     254,   256,   260,   261,    62,   255,    63,    63,    63,    61,
-      72,    72,   152,   162,   162,   162,   162,   157,   161,   161,
-     239,    99,   163,   184,   196,   197,   169,   140,   174,   140,
-     159,   160,   163,   175,   184,   186,   197,   219,   274,   184,
-     184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
-     184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
-     184,   184,   184,   184,   184,    51,    52,    55,   182,   187,
-     310,   311,   189,    51,    52,    55,   182,   187,   310,    51,
-      55,   310,   244,   243,   160,   184,   186,   160,   186,    98,
-     165,   212,   276,   211,    51,    55,   176,   310,   189,   310,
-     154,   161,   216,   217,    15,    13,   247,   322,   155,    16,
-      51,    55,   189,    51,    55,   155,    27,   221,   319,   221,
-      51,    55,   189,    51,    55,   209,   181,   155,   245,   184,
-     196,    15,   260,   184,   184,   316,    99,   184,   193,   306,
-     184,   308,   317,   143,   315,   195,   195,   317,   143,   179,
-     150,   137,   186,   317,   157,   201,   306,   171,   173,    51,
-      55,   189,    51,    55,    57,   119,   291,   287,   204,   184,
-     140,   302,   322,    51,   140,   302,   140,   286,   184,   140,
-     286,    51,   140,   286,    51,    63,   155,   261,   184,   184,
-      80,   124,   230,   231,   322,   184,   195,   317,   173,   140,
-      44,   119,    44,    89,   138,   313,   316,    91,    91,   187,
-     191,   139,    91,    91,   188,   191,   188,   191,   230,   230,
-     166,   319,   162,   154,   139,    15,   317,   142,   277,   287,
-     178,   184,   197,   248,   322,    18,   223,   322,    17,   222,
-     223,    91,    91,   139,    91,    91,   223,   206,   208,   139,
-     162,   179,   137,    15,   195,   220,   260,   184,   194,   306,
-     137,   317,   318,   139,    51,    99,   225,   292,   233,   316,
-      29,   111,   237,    51,   279,   284,   301,   285,   290,   297,
-     299,   292,   294,   299,    51,   292,   137,   227,   229,   232,
-     278,   280,   281,   284,   292,   293,   295,   296,   299,   301,
-     154,    99,   184,   173,   157,   184,    51,    55,   189,    51,
-      55,    57,   121,   160,   186,   163,   186,   165,    91,   160,
-     186,   160,   186,   165,   242,   238,   154,   155,   230,   213,
-     319,    15,    84,   287,   154,   319,   218,    92,   249,   322,
-     155,    14,   250,   322,   162,    15,    91,    15,   155,   155,
-     221,   184,   155,   195,   140,   289,   317,   140,   143,   144,
-     154,   155,   302,   140,   286,   140,   286,   140,   286,   140,
-     286,   286,   233,   233,    90,   219,   140,   302,   302,   140,
-     228,   219,   140,   228,   140,   228,    15,   184,   139,   184,
-     184,   160,   186,    15,   137,   155,   154,   317,   317,    15,
-     277,    90,   175,   219,   271,   274,   220,   155,   220,    15,
-      15,   210,   223,   245,   246,   226,   140,    99,    51,   234,
-     235,   288,    15,   137,   292,   299,   292,   292,   124,   124,
-      55,    89,   280,   284,   140,   227,   228,   296,   299,   292,
-     295,   299,   292,   137,    15,   154,    55,    89,   138,   313,
-     155,   155,   155,   292,   292,   140,   289,   140,   316,   286,
-     140,   286,   286,   286,    51,    55,   302,   140,   228,   140,
-     228,   140,   228,   140,   228,   228,    15,    51,    55,   189,
-      51,    55,   247,   222,    15,   140,   292,   140,   235,   292,
-     292,   299,   292,   292,   139,   292,   286,   228,   140,   228,
-     228,   228,   292,   228
+     159,   160,   162,   163,   164,   167,   168,   171,   172,   174,
+     175,   176,   178,   179,   188,   202,   219,   240,   241,   251,
+     252,   253,   257,   258,   259,   265,   266,   267,   269,   270,
+     271,   272,   273,   274,   310,   323,   152,    21,    22,    30,
+      31,    32,    39,    51,    55,    69,    87,    90,    93,   132,
+     163,   164,   180,   181,   202,   219,   271,   274,   310,   181,
+       3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
+      23,    24,    25,    26,    30,    31,    32,    33,    34,    35,
+      36,    37,    38,    39,    45,    46,    47,    48,    49,    50,
+      51,    52,    55,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    81,    82,    85,    86,    87,    88,    99,   100,
+     122,   123,   124,   125,   126,   127,   128,   129,   130,   131,
+     133,   134,   141,   142,   182,   186,   187,   273,   304,   203,
+      90,   162,   166,   179,   188,   219,   271,   272,   274,   166,
+     209,   211,    69,    90,   172,   179,   219,   224,   271,   274,
+      33,    34,    35,    36,    48,    49,    50,    51,    55,   104,
+     182,   183,   184,   267,   113,   116,   117,   144,   146,   166,
+     261,   262,   263,   316,   320,   321,   322,    51,    99,   100,
+     101,   133,   171,   188,   194,   197,   200,   253,   307,   309,
+     194,   194,   142,   191,   192,   195,   196,   323,   191,   195,
+     142,   317,   321,   183,   153,   136,   188,   219,   188,    55,
+       1,    93,   155,   156,   157,   173,   174,   323,   204,   206,
+     189,   200,   307,   323,   188,   306,   307,   323,    90,   140,
+     178,   219,   271,   274,   207,    53,    54,    56,    63,   108,
+     182,   268,    62,    64,    65,   114,   115,   254,   255,    63,
+     254,    63,   254,    63,   254,    61,   254,    58,    59,   167,
+     188,   188,   316,   322,    40,    41,    42,    43,    44,    92,
+      37,    38,    51,    53,    54,    55,    56,    69,    72,    93,
+      99,   100,   101,   126,   129,   142,   277,   278,   279,   280,
+     283,   284,   285,   286,   288,   289,   290,   291,   293,   294,
+     295,   298,   299,   300,   301,   302,   277,   278,    28,   238,
+     119,   140,    93,    99,   175,   119,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    87,
+      88,    92,   120,   122,   123,   124,   125,   126,   127,   128,
+     129,   130,   131,    89,   103,   138,   145,   314,    89,   314,
+     315,    26,   136,   242,   253,    91,    91,   191,   195,   242,
+     162,    51,    55,   180,    58,    59,   277,   123,   275,    89,
+     138,   314,   218,   305,    89,   145,   313,   154,   155,    55,
+      16,   220,   320,   119,    89,   138,   314,    91,    91,   220,
+     166,   166,    55,    89,   138,   314,    25,   108,   140,   264,
+     316,   113,   263,    20,   245,   320,    57,   308,   188,   188,
+     188,    92,   140,   198,   199,   323,   308,   198,   199,    84,
+     193,   194,   200,   307,   323,   194,   162,   316,   318,   162,
+     158,   136,   155,    89,   314,    91,   157,   173,   143,   316,
+     322,   318,   157,   318,   139,   199,   319,   322,   199,   319,
+     137,   319,    55,   175,   176,   177,   140,    89,   138,   314,
+     142,   236,   288,    63,   254,   256,   260,   261,    62,   255,
+      63,    63,    63,    61,    72,    72,   152,   166,   166,   166,
+     166,   157,   172,   179,   162,   162,    57,   119,   292,    84,
+     288,   119,   154,   188,   140,   303,   323,    51,   140,   303,
+     320,   140,   287,   188,   140,   287,    51,   140,   287,    51,
+     119,   154,   239,    99,   167,   188,   200,   201,   173,   140,
+     178,   140,   160,   161,   167,   179,   188,   190,   201,   219,
+     274,   188,   188,   188,   188,   188,   188,   188,   188,   188,
+     188,   188,   188,   188,   188,   188,   172,   179,   188,   188,
+     188,   188,   188,   188,   188,   188,   188,   188,   188,    51,
+      52,    55,   186,   191,   311,   312,   193,    51,    52,    55,
+     186,   191,   311,    51,    55,   311,   244,   243,   161,   188,
+     190,   161,   190,    98,   169,   216,   276,   215,    51,    55,
+     180,   311,   193,   311,   154,   162,   165,    15,    13,   247,
+     323,   155,    16,    51,    55,   193,    51,    55,   155,    27,
+     221,   320,   221,    51,    55,   193,    51,    55,   213,   185,
+     155,   245,   188,   200,    15,   260,   188,   188,   317,    99,
+     188,   197,   307,   188,   309,   318,   143,   316,   199,   199,
+     318,   143,   183,   150,   137,   190,   318,   157,   205,   307,
+     175,   177,    51,    55,   193,    51,    55,   288,   208,    63,
+     155,   261,   188,   188,    51,    99,   225,   293,   318,   318,
+     188,    15,    51,   280,   285,   302,   286,   291,   298,   300,
+     293,   295,   300,    51,   293,   188,    15,    80,   124,   230,
+     231,   323,   188,   199,   318,   177,   140,    44,   119,    44,
+      89,   138,   314,   317,    91,    91,   191,   195,   139,    91,
+      91,   192,   195,   192,   195,   230,   230,   170,   320,   166,
+     154,   139,    15,   318,   182,   188,   201,   248,   323,    18,
+     223,   323,    17,   222,   223,    91,    91,   139,    91,    91,
+     223,   210,   212,   139,   166,   183,   137,    15,   199,   220,
+     260,   188,   198,   307,   137,   318,   319,   139,   233,   317,
+      29,   111,   237,   137,   140,   290,   318,   140,    44,   303,
+     140,   287,   140,   287,   140,   287,   140,   287,   287,    44,
+     227,   229,   232,   279,   281,   282,   285,   293,   294,   296,
+     297,   300,   302,   154,    99,   188,   177,   157,   188,    51,
+      55,   193,    51,    55,    57,   121,   161,   190,   167,   190,
+     169,    91,   161,   190,   161,   190,   169,   242,   238,   154,
+     155,   230,   217,   320,    15,    92,   249,   323,   155,    14,
+     250,   323,   166,    15,    91,    15,   155,   155,   221,   188,
+     155,   199,   143,   144,   154,   155,   226,   140,    99,   188,
+     293,   300,   293,   293,   188,   233,   233,    90,   219,   140,
+     303,   303,   140,   228,   219,   140,   228,   140,   228,    15,
+     188,   139,   188,   188,   161,   190,    15,   137,   155,   154,
+      90,   179,   219,   271,   274,   220,   155,   220,    15,    15,
+     214,   223,   245,   246,    51,   234,   235,   289,    15,   137,
+     293,   293,   140,   290,   287,   140,   287,   287,   287,   124,
+     124,    55,    89,   281,   285,   140,   227,   228,   297,   300,
+     293,   296,   300,   293,   137,    15,    55,    89,   138,   314,
+     155,   155,   155,   140,   317,   140,   293,   140,   293,    51,
+      55,   303,   140,   228,   140,   228,   140,   228,   140,   228,
+     228,    51,    55,   193,    51,    55,   247,   222,    15,   235,
+     293,   287,   293,   300,   293,   293,   139,   228,   140,   228,
+     228,   228,   293,   228
 };
 
   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
@@ -4843,63 +4948,64 @@ static const yytype_int16 yyr1[] =
        0,   147,   149,   148,   150,   151,   151,   151,   151,   152,
      153,   152,   154,   155,   156,   156,   156,   156,   158,   157,
      157,   157,   157,   157,   157,   157,   157,   157,   157,   157,
-     157,   157,   157,   159,   159,   159,   159,   159,   159,   159,
-     159,   160,   160,   160,   161,   161,   161,   161,   161,   161,
-     162,   163,   163,   164,   164,   166,   165,   167,   167,   167,
-     167,   167,   167,   167,   167,   167,   167,   167,   168,   168,
-     169,   169,   170,   170,   170,   170,   170,   170,   170,   170,
-     170,   170,   171,   171,   172,   172,   173,   173,   174,   174,
-     174,   174,   174,   174,   174,   174,   175,   175,   175,   175,
-     175,   175,   175,   175,   175,   176,   176,   177,   177,   177,
-     178,   178,   178,   178,   178,   179,   179,   180,   181,   180,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     182,   182,   182,   182,   182,   182,   182,   182,   182,   182,
-     183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
-     183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
-     183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
-     183,   183,   183,   183,   183,   183,   183,   183,   183,   183,
-     184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
-     184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
-     184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
-     184,   184,   184,   184,   184,   184,   184,   184,   184,   184,
-     184,   184,   184,   185,   185,   185,   185,   186,   186,   187,
-     187,   188,   188,   189,   189,   189,   189,   189,   190,   190,
-     190,   190,   190,   192,   191,   193,   194,   194,   195,   195,
-     196,   196,   196,   196,   197,   197,   197,   198,   198,   198,
-     198,   198,   198,   198,   198,   198,   199,   198,   200,   201,
-     198,   202,   198,   198,   198,   198,   198,   198,   198,   198,
-     198,   198,   198,   198,   198,   203,   204,   198,   198,   198,
-     205,   206,   198,   207,   208,   198,   198,   198,   209,   210,
-     198,   211,   198,   212,   213,   198,   214,   198,   215,   216,
-     198,   217,   218,   198,   198,   198,   198,   198,   219,   220,
-     220,   220,   221,   221,   222,   222,   223,   223,   224,   224,
-     225,   225,   225,   225,   225,   225,   225,   225,   226,   225,
-     227,   227,   227,   227,   228,   228,   229,   229,   229,   229,
-     229,   229,   229,   229,   229,   229,   229,   229,   229,   229,
-     229,   230,   230,   232,   231,   231,   231,   233,   233,   234,
-     234,   235,   235,   236,   236,   237,   237,   239,   238,   240,
-     240,   240,   240,   241,   241,   241,   241,   241,   241,   241,
-     241,   241,   243,   242,   244,   242,   245,   246,   246,   247,
-     247,   248,   248,   248,   249,   249,   250,   250,   251,   251,
-     251,   251,   252,   252,   253,   253,   253,   253,   254,   254,
-     255,   256,   255,   255,   255,   257,   257,   258,   258,   259,
-     260,   260,   261,   261,   262,   262,   263,   264,   263,   265,
-     265,   266,   266,   267,   268,   268,   268,   268,   268,   268,
-     269,   269,   270,   270,   270,   270,   271,   271,   271,   271,
-     271,   272,   272,   273,   273,   273,   273,   273,   273,   273,
-     273,   274,   274,   275,   276,   275,   277,   277,   277,   278,
-     279,   279,   280,   280,   281,   281,   282,   282,   283,   283,
-     284,   284,   285,   285,   285,   285,   286,   286,   287,   287,
-     287,   287,   287,   287,   287,   287,   287,   287,   287,   287,
-     287,   287,   287,   288,   288,   288,   288,   288,   289,   289,
-     290,   291,   290,   292,   292,   293,   294,   295,   296,   296,
-     297,   297,   298,   298,   299,   299,   300,   300,   301,   302,
-     302,   303,   304,   303,   305,   305,   306,   306,   307,   307,
-     308,   308,   308,   308,   309,   309,   309,   310,   310,   310,
-     310,   311,   311,   311,   312,   312,   313,   313,   314,   314,
-     315,   315,   316,   316,   317,   318,   318,   318,   319,   319,
-     319,   320,   321,   321,   322
+     157,   157,   157,   157,   159,   159,   159,   159,   160,   160,
+     160,   160,   160,   160,   160,   160,   161,   161,   161,   162,
+     162,   162,   162,   162,   162,   163,   165,   164,   166,   167,
+     167,   168,   168,   170,   169,   171,   171,   171,   171,   171,
+     171,   171,   171,   171,   171,   171,   172,   172,   173,   173,
+     174,   174,   174,   174,   174,   174,   174,   174,   174,   174,
+     175,   175,   176,   176,   177,   177,   178,   178,   178,   178,
+     178,   178,   178,   178,   179,   179,   179,   179,   179,   179,
+     179,   179,   179,   180,   180,   181,   181,   181,   182,   182,
+     182,   182,   182,   183,   183,   184,   185,   184,   186,   186,
+     186,   186,   186,   186,   186,   186,   186,   186,   186,   186,
+     186,   186,   186,   186,   186,   186,   186,   186,   186,   186,
+     186,   186,   186,   186,   186,   186,   186,   186,   187,   187,
+     187,   187,   187,   187,   187,   187,   187,   187,   187,   187,
+     187,   187,   187,   187,   187,   187,   187,   187,   187,   187,
+     187,   187,   187,   187,   187,   187,   187,   187,   187,   187,
+     187,   187,   187,   187,   187,   187,   187,   187,   188,   188,
+     188,   188,   188,   188,   188,   188,   188,   188,   188,   188,
+     188,   188,   188,   188,   188,   188,   188,   188,   188,   188,
+     188,   188,   188,   188,   188,   188,   188,   188,   188,   188,
+     188,   188,   188,   188,   188,   188,   188,   188,   188,   188,
+     188,   188,   188,   188,   188,   189,   189,   189,   189,   190,
+     190,   191,   191,   192,   192,   193,   193,   193,   193,   193,
+     194,   194,   194,   194,   194,   196,   195,   197,   198,   198,
+     199,   199,   200,   200,   200,   200,   201,   201,   201,   202,
+     202,   202,   202,   202,   202,   202,   202,   202,   203,   202,
+     204,   205,   202,   206,   202,   202,   202,   202,   202,   202,
+     202,   202,   202,   202,   202,   202,   202,   207,   208,   202,
+     202,   202,   209,   210,   202,   211,   212,   202,   202,   202,
+     213,   214,   202,   215,   202,   216,   217,   202,   218,   202,
+     202,   202,   202,   202,   202,   202,   219,   220,   220,   220,
+     221,   221,   222,   222,   223,   223,   224,   224,   225,   225,
+     225,   225,   225,   225,   225,   225,   226,   225,   227,   227,
+     227,   227,   228,   228,   229,   229,   229,   229,   229,   229,
+     229,   229,   229,   229,   229,   229,   229,   229,   229,   230,
+     230,   232,   231,   231,   231,   233,   233,   234,   234,   235,
+     235,   236,   236,   237,   237,   239,   238,   240,   240,   240,
+     240,   241,   241,   241,   241,   241,   241,   241,   241,   241,
+     243,   242,   244,   242,   245,   246,   246,   247,   247,   248,
+     248,   248,   249,   249,   250,   250,   251,   251,   251,   251,
+     252,   252,   253,   253,   253,   253,   254,   254,   255,   256,
+     255,   255,   255,   257,   257,   258,   258,   259,   260,   260,
+     261,   261,   262,   262,   263,   264,   263,   265,   265,   266,
+     266,   267,   268,   268,   268,   268,   268,   268,   269,   269,
+     270,   270,   270,   270,   271,   271,   271,   271,   271,   272,
+     272,   273,   273,   273,   273,   273,   273,   273,   273,   274,
+     274,   275,   276,   275,   277,   277,   278,   278,   279,   280,
+     280,   281,   281,   282,   282,   283,   283,   284,   284,   285,
+     285,   286,   286,   286,   286,   287,   287,   288,   288,   288,
+     288,   288,   288,   288,   288,   288,   288,   288,   288,   288,
+     288,   288,   289,   289,   289,   289,   289,   290,   290,   291,
+     292,   291,   293,   293,   294,   295,   296,   297,   297,   298,
+     298,   299,   299,   300,   300,   301,   301,   302,   303,   303,
+     304,   305,   304,   306,   306,   307,   307,   308,   308,   309,
+     309,   309,   309,   310,   310,   310,   311,   311,   311,   311,
+     312,   312,   312,   313,   313,   314,   314,   315,   315,   316,
+     316,   317,   317,   318,   319,   319,   319,   320,   320,   320,
+     321,   322,   322,   323
 };
 
   /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
@@ -4908,63 +5014,64 @@ static const yytype_int8 yyr2[] =
        0,     2,     0,     2,     2,     1,     1,     3,     2,     1,
        0,     5,     4,     2,     1,     1,     3,     2,     0,     4,
        2,     3,     3,     3,     3,     3,     4,     1,     3,     3,
-       3,     3,     1,     3,     3,     6,     5,     5,     5,     5,
-       3,     1,     3,     1,     1,     3,     3,     3,     2,     1,
-       1,     1,     1,     1,     4,     0,     5,     2,     3,     4,
-       5,     4,     5,     2,     2,     2,     2,     2,     1,     3,
-       1,     3,     1,     2,     3,     5,     2,     4,     2,     4,
-       1,     3,     1,     3,     2,     3,     1,     2,     1,     4,
-       3,     3,     3,     3,     2,     1,     1,     4,     3,     3,
-       3,     3,     2,     1,     1,     1,     1,     2,     1,     3,
-       1,     1,     1,     1,     1,     1,     1,     1,     0,     4,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       3,     3,     1,     1,     3,     3,     3,     3,     3,     3,
+       6,     5,     5,     5,     5,     3,     1,     3,     1,     1,
+       3,     3,     3,     2,     1,     2,     0,     5,     1,     1,
+       1,     1,     4,     0,     5,     2,     3,     4,     5,     4,
+       5,     2,     2,     2,     2,     2,     1,     3,     1,     3,
+       1,     2,     3,     5,     2,     4,     2,     4,     1,     3,
+       1,     3,     2,     3,     1,     2,     1,     4,     3,     3,
+       3,     3,     2,     1,     1,     4,     3,     3,     3,     3,
+       2,     1,     1,     1,     1,     2,     1,     3,     1,     1,
+       1,     1,     1,     1,     1,     1,     0,     4,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       3,     3,     6,     5,     5,     5,     5,     4,     3,     3,
-       3,     3,     3,     3,     3,     3,     3,     4,     4,     2,
-       2,     3,     3,     3,     3,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     2,     2,     3,     3,     3,     3,
-       6,     6,     1,     1,     2,     4,     2,     1,     3,     3,
-       3,     1,     1,     1,     2,     2,     4,     2,     1,     2,
-       2,     4,     1,     0,     2,     2,     2,     1,     1,     3,
-       1,     2,     3,     4,     3,     4,     2,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     0,     4,     0,     0,
-       5,     0,     3,     3,     3,     2,     3,     3,     1,     2,
-       4,     3,     2,     1,     2,     0,     0,     5,     6,     6,
-       0,     0,     7,     0,     0,     7,     5,     4,     0,     0,
-       9,     0,     6,     0,     0,     8,     0,     5,     0,     0,
-       7,     0,     0,     9,     1,     1,     1,     1,     1,     1,
-       1,     2,     1,     1,     1,     5,     1,     2,     1,     1,
-       1,     4,     6,     3,     5,     2,     4,     1,     0,     4,
-       4,     2,     2,     1,     2,     0,     6,     8,     4,     6,
-       4,     3,     6,     2,     4,     6,     2,     4,     2,     4,
-       1,     1,     1,     0,     4,     1,     4,     1,     4,     1,
-       3,     1,     1,     4,     1,     3,     3,     0,     5,     2,
-       4,     5,     5,     2,     4,     4,     3,     3,     3,     2,
-       1,     4,     0,     5,     0,     5,     5,     1,     1,     6,
-       1,     1,     1,     1,     2,     1,     2,     1,     1,     1,
-       1,     1,     1,     2,     1,     1,     2,     3,     1,     2,
-       1,     0,     4,     1,     2,     2,     3,     2,     3,     1,
-       1,     2,     1,     2,     1,     2,     1,     0,     4,     2,
-       3,     1,     4,     2,     1,     1,     1,     1,     1,     2,
-       2,     3,     1,     1,     2,     2,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     0,     0,     4,     3,     3,     2,     2,
-       2,     1,     2,     1,     1,     3,     1,     3,     1,     1,
-       2,     1,     4,     2,     2,     1,     2,     0,     6,     8,
-       4,     6,     4,     6,     2,     4,     6,     2,     4,     2,
-       4,     1,     0,     1,     1,     1,     1,     1,     1,     1,
-       1,     0,     4,     1,     3,     2,     2,     2,     1,     3,
-       1,     3,     1,     1,     2,     1,     1,     1,     2,     2,
-       1,     1,     0,     4,     1,     2,     1,     3,     1,     2,
-       3,     3,     3,     2,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     3,     3,
+       6,     5,     5,     5,     5,     4,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     4,     4,     2,     2,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     2,     2,     3,     3,     3,     3,     6,     6,
+       4,     6,     4,     6,     1,     1,     2,     4,     2,     1,
+       3,     3,     3,     1,     1,     1,     2,     2,     4,     2,
+       1,     2,     2,     4,     1,     0,     2,     2,     2,     1,
+       1,     3,     1,     2,     3,     4,     3,     4,     2,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     0,     4,
+       0,     0,     5,     0,     3,     3,     3,     2,     3,     3,
+       1,     2,     4,     3,     2,     1,     2,     0,     0,     5,
+       6,     6,     0,     0,     7,     0,     0,     7,     5,     4,
+       0,     0,     9,     0,     6,     0,     0,     8,     0,     5,
+       4,     4,     1,     1,     1,     1,     1,     1,     1,     2,
+       1,     1,     1,     5,     1,     2,     1,     1,     1,     4,
+       6,     3,     5,     2,     4,     1,     0,     4,     4,     2,
+       2,     1,     2,     0,     6,     8,     4,     6,     4,     3,
+       6,     2,     4,     6,     2,     4,     2,     4,     1,     1,
+       1,     0,     4,     1,     4,     1,     4,     1,     3,     1,
+       1,     4,     1,     3,     3,     0,     5,     2,     4,     5,
+       5,     2,     4,     4,     3,     3,     3,     2,     1,     4,
+       0,     5,     0,     5,     5,     1,     1,     6,     1,     1,
+       1,     1,     2,     1,     2,     1,     1,     1,     1,     1,
+       1,     2,     1,     1,     2,     3,     1,     2,     1,     0,
+       4,     1,     2,     2,     3,     2,     3,     1,     1,     2,
+       1,     2,     1,     2,     1,     0,     4,     2,     3,     1,
+       4,     2,     1,     1,     1,     1,     1,     2,     2,     3,
+       1,     1,     2,     2,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       0,     1,     0,     1,     2,     0,     1,     1,     1,     1,
-       1,     1,     1,     2,     0
+       1,     0,     0,     4,     3,     3,     1,     2,     2,     2,
+       1,     2,     1,     1,     3,     1,     3,     1,     1,     2,
+       1,     4,     2,     2,     1,     2,     0,     6,     8,     4,
+       6,     4,     6,     2,     4,     6,     2,     4,     2,     4,
+       1,     0,     1,     1,     1,     1,     1,     1,     1,     1,
+       0,     4,     1,     3,     2,     2,     2,     1,     3,     1,
+       3,     1,     1,     2,     1,     1,     1,     2,     2,     1,
+       1,     0,     4,     1,     2,     1,     3,     1,     2,     3,
+       3,     3,     2,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     0,
+       1,     0,     1,     2,     0,     1,     1,     1,     1,     1,
+       1,     1,     2,     0
 };
 
 
@@ -5666,86 +5773,86 @@ yyreduce:
   switch (yyn)
     {
   case 2:
-#line 1508 "mrbgems/mruby-compiler/core/parse.y"
+#line 1534 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lstate = EXPR_BEG;
                       if (!p->locals) p->locals = cons(0,0);
                     }
-#line 5675 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5782 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 3:
-#line 1513 "mrbgems/mruby-compiler/core/parse.y"
+#line 1539 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->tree = new_scope(p, (yyvsp[0].nd));
                       NODE_LINENO(p->tree, (yyvsp[0].nd));
                     }
-#line 5684 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5791 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 4:
-#line 1520 "mrbgems/mruby-compiler/core/parse.y"
+#line 1546 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 5692 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5799 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 5:
-#line 1526 "mrbgems/mruby-compiler/core/parse.y"
+#line 1552 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_begin(p, 0);
                     }
-#line 5700 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5807 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 6:
-#line 1530 "mrbgems/mruby-compiler/core/parse.y"
+#line 1556 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_begin(p, (yyvsp[0].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[0].nd));
                     }
-#line 5709 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5816 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 7:
-#line 1535 "mrbgems/mruby-compiler/core/parse.y"
+#line 1561 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
                     }
-#line 5717 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5824 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 8:
-#line 1539 "mrbgems/mruby-compiler/core/parse.y"
+#line 1565 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_begin(p, 0);
                     }
-#line 5725 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5832 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 10:
-#line 1546 "mrbgems/mruby-compiler/core/parse.y"
+#line 1572 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = local_switch(p);
                       nvars_block(p);
                     }
-#line 5734 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5841 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 11:
-#line 1551 "mrbgems/mruby-compiler/core/parse.y"
+#line 1577 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "BEGIN not supported");
                       local_resume(p, (yyvsp[-3].nd));
                       nvars_unnest(p);
                       (yyval.nd) = 0;
                     }
-#line 5745 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5852 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 12:
-#line 1563 "mrbgems/mruby-compiler/core/parse.y"
+#line 1589 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if ((yyvsp[-2].nd)) {
                         (yyval.nd) = new_rescue(p, (yyvsp[-3].nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
@@ -5767,1344 +5874,1462 @@ yyreduce:
                         }
                       }
                     }
-#line 5771 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5878 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 13:
-#line 1587 "mrbgems/mruby-compiler/core/parse.y"
+#line 1613 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 5779 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5886 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 14:
-#line 1593 "mrbgems/mruby-compiler/core/parse.y"
+#line 1619 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_begin(p, 0);
                     }
-#line 5787 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5894 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 15:
-#line 1597 "mrbgems/mruby-compiler/core/parse.y"
+#line 1623 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_begin(p, (yyvsp[0].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[0].nd));
                     }
-#line 5796 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5903 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 16:
-#line 1602 "mrbgems/mruby-compiler/core/parse.y"
+#line 1628 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), newline_node((yyvsp[0].nd)));
                     }
-#line 5804 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5911 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 17:
-#line 1606 "mrbgems/mruby-compiler/core/parse.y"
+#line 1632 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_begin(p, (yyvsp[0].nd));
                     }
-#line 5812 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5919 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 18:
-#line 1611 "mrbgems/mruby-compiler/core/parse.y"
+#line 1637 "mrbgems/mruby-compiler/core/parse.y"
                                      {p->lstate = EXPR_FNAME;}
-#line 5818 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5925 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 19:
-#line 1612 "mrbgems/mruby-compiler/core/parse.y"
+#line 1638 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_alias(p, (yyvsp[-2].id), (yyvsp[0].id));
                     }
-#line 5826 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5933 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 20:
-#line 1616 "mrbgems/mruby-compiler/core/parse.y"
+#line 1642 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 5834 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5941 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 21:
-#line 1620 "mrbgems/mruby-compiler/core/parse.y"
+#line 1646 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_if(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
                     }
-#line 5842 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5949 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 22:
-#line 1624 "mrbgems/mruby-compiler/core/parse.y"
+#line 1650 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_unless(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd), 0);
                     }
-#line 5850 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5957 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 23:
-#line 1628 "mrbgems/mruby-compiler/core/parse.y"
+#line 1654 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_while(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
                     }
-#line 5858 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5965 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 24:
-#line 1632 "mrbgems/mruby-compiler/core/parse.y"
+#line 1658 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_until(p, cond((yyvsp[0].nd)), (yyvsp[-2].nd));
                     }
-#line 5866 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5973 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 25:
-#line 1636 "mrbgems/mruby-compiler/core/parse.y"
+#line 1662 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 5874 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5981 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 26:
-#line 1640 "mrbgems/mruby-compiler/core/parse.y"
+#line 1666 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "END not supported");
                       (yyval.nd) = new_postexe(p, (yyvsp[-1].nd));
                     }
-#line 5883 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5990 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 28:
-#line 1646 "mrbgems/mruby-compiler/core/parse.y"
+#line 1672 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 5891 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 5998 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 29:
-#line 1650 "mrbgems/mruby-compiler/core/parse.y"
+#line 1676 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
                     }
-#line 5899 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6006 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 30:
-#line 1654 "mrbgems/mruby-compiler/core/parse.y"
+#line 1680 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 5907 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6014 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 31:
-#line 1658 "mrbgems/mruby-compiler/core/parse.y"
+#line 1684 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_masgn(p, (yyvsp[-2].nd), new_array(p, (yyvsp[0].nd)));
                     }
-#line 5915 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6022 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 34:
+#line 1692 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      void_expr_error(p, (yyvsp[-2].nd));
+                      (yyval.nd) = new_asgn(p, (yyvsp[0].nd), (yyvsp[-2].nd));
+                    }
+#line 6031 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 35:
+#line 1697 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      void_expr_error(p, (yyvsp[-2].nd));
+                      (yyval.nd) = new_masgn(p, (yyvsp[0].nd), (yyvsp[-2].nd));
+                    }
+#line 6040 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 36:
+#line 1702 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      (yyval.nd) = new_asgn(p, (yyvsp[0].nd), (yyvsp[-2].nd));
+                    }
+#line 6048 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 37:
+#line 1706 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      (yyval.nd) = new_masgn(p, (yyvsp[0].nd), (yyvsp[-2].nd));
+                    }
+#line 6056 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 33:
-#line 1665 "mrbgems/mruby-compiler/core/parse.y"
+  case 38:
+#line 1712 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 5923 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6064 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 34:
-#line 1669 "mrbgems/mruby-compiler/core/parse.y"
+  case 39:
+#line 1716 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 5931 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6072 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 35:
-#line 1673 "mrbgems/mruby-compiler/core/parse.y"
+  case 40:
+#line 1720 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_lit("[]"), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
+                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), MRB_QSYM(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 5939 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6080 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 36:
-#line 1677 "mrbgems/mruby-compiler/core/parse.y"
+  case 41:
+#line 1724 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 5947 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6088 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 37:
-#line 1681 "mrbgems/mruby-compiler/core/parse.y"
+  case 42:
+#line 1728 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 5955 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6096 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 38:
-#line 1685 "mrbgems/mruby-compiler/core/parse.y"
+  case 43:
+#line 1732 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "constant re-assignment");
                       (yyval.nd) = 0;
                     }
-#line 5964 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6105 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 39:
-#line 1690 "mrbgems/mruby-compiler/core/parse.y"
+  case 44:
+#line 1737 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 5972 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6113 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 40:
-#line 1694 "mrbgems/mruby-compiler/core/parse.y"
+  case 45:
+#line 1741 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       backref_error(p, (yyvsp[-2].nd));
                       (yyval.nd) = new_begin(p, 0);
                     }
-#line 5981 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6122 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 42:
-#line 1702 "mrbgems/mruby-compiler/core/parse.y"
+  case 47:
+#line 1749 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 5989 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6130 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 45:
-#line 1711 "mrbgems/mruby-compiler/core/parse.y"
+  case 50:
+#line 1758 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 5997 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6138 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 46:
-#line 1715 "mrbgems/mruby-compiler/core/parse.y"
+  case 51:
+#line 1762 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 6005 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6146 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 47:
-#line 1719 "mrbgems/mruby-compiler/core/parse.y"
+  case 52:
+#line 1766 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
                     }
-#line 6013 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6154 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 48:
-#line 1723 "mrbgems/mruby-compiler/core/parse.y"
+  case 53:
+#line 1770 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
                     }
-#line 6021 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6162 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 50:
-#line 1730 "mrbgems/mruby-compiler/core/parse.y"
+  case 55:
+#line 1778 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      (yyval.nd) = new_def(p, (yyvsp[0].id), nint(p->cmdarg_stack), local_switch(p));
+                      p->cmdarg_stack = 0;
+                      p->in_def++;
+                      nvars_block(p);
+                    }
+#line 6173 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 56:
+#line 1787 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      p->lstate = EXPR_FNAME;
+                    }
+#line 6181 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 57:
+#line 1791 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      (yyval.nd) = new_sdef(p, (yyvsp[-3].nd), (yyvsp[0].id), nint(p->cmdarg_stack), local_switch(p));
+                      p->cmdarg_stack = 0;
+                      p->in_def++;
+                      p->in_single++;
+                      nvars_block(p);
+                      p->lstate = EXPR_ENDFN; /* force for args */
+                    }
+#line 6194 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 58:
+#line 1802 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if (!(yyvsp[0].nd)) (yyval.nd) = new_nil(p);
                       else {
                         (yyval.nd) = (yyvsp[0].nd);
                       }
                     }
-#line 6032 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6205 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 54:
-#line 1744 "mrbgems/mruby-compiler/core/parse.y"
+  case 62:
+#line 1816 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
                     }
-#line 6040 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6213 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 55:
-#line 1750 "mrbgems/mruby-compiler/core/parse.y"
+  case 63:
+#line 1822 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_nest(p);
                       nvars_nest(p);
                     }
-#line 6049 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6222 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 56:
-#line 1757 "mrbgems/mruby-compiler/core/parse.y"
+  case 64:
+#line 1829 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_block(p, (yyvsp[-2].nd), (yyvsp[-1].nd));
                       local_unnest(p);
                       nvars_unnest(p);
                     }
-#line 6059 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6232 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 57:
-#line 1765 "mrbgems/mruby-compiler/core/parse.y"
+  case 65:
+#line 1837 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 6067 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6240 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 58:
-#line 1769 "mrbgems/mruby-compiler/core/parse.y"
+  case 66:
+#line 1841 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
                       (yyval.nd) = new_fcall(p, (yyvsp[-2].id), (yyvsp[-1].nd));
                     }
-#line 6076 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6249 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 59:
-#line 1774 "mrbgems/mruby-compiler/core/parse.y"
+  case 67:
+#line 1846 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
                     }
-#line 6084 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6257 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 60:
-#line 1778 "mrbgems/mruby-compiler/core/parse.y"
+  case 68:
+#line 1850 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
                       (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
                    }
-#line 6093 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6266 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 61:
-#line 1783 "mrbgems/mruby-compiler/core/parse.y"
+  case 69:
+#line 1855 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
                     }
-#line 6101 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6274 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 62:
-#line 1787 "mrbgems/mruby-compiler/core/parse.y"
+  case 70:
+#line 1859 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       args_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
                       (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), tCOLON2);
                     }
-#line 6110 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6283 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 63:
-#line 1792 "mrbgems/mruby-compiler/core/parse.y"
+  case 71:
+#line 1864 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_super(p, (yyvsp[0].nd));
                     }
-#line 6118 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6291 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 64:
-#line 1796 "mrbgems/mruby-compiler/core/parse.y"
+  case 72:
+#line 1868 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_yield(p, (yyvsp[0].nd));
                     }
-#line 6126 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6299 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 65:
-#line 1800 "mrbgems/mruby-compiler/core/parse.y"
+  case 73:
+#line 1872 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_return(p, ret_args(p, (yyvsp[0].nd)));
                     }
-#line 6134 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6307 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 66:
-#line 1804 "mrbgems/mruby-compiler/core/parse.y"
+  case 74:
+#line 1876 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_break(p, ret_args(p, (yyvsp[0].nd)));
                     }
-#line 6142 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6315 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 67:
-#line 1808 "mrbgems/mruby-compiler/core/parse.y"
+  case 75:
+#line 1880 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_next(p, ret_args(p, (yyvsp[0].nd)));
                     }
-#line 6150 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6323 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 68:
-#line 1814 "mrbgems/mruby-compiler/core/parse.y"
+  case 76:
+#line 1886 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 6158 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6331 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 69:
-#line 1818 "mrbgems/mruby-compiler/core/parse.y"
+  case 77:
+#line 1890 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 6166 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6339 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 71:
-#line 1825 "mrbgems/mruby-compiler/core/parse.y"
+  case 79:
+#line 1897 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 6174 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6347 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 72:
-#line 1831 "mrbgems/mruby-compiler/core/parse.y"
+  case 80:
+#line 1903 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 6182 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6355 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 73:
-#line 1835 "mrbgems/mruby-compiler/core/parse.y"
+  case 81:
+#line 1907 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1(push((yyvsp[-1].nd),(yyvsp[0].nd)));
                     }
-#line 6190 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6363 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 74:
-#line 1839 "mrbgems/mruby-compiler/core/parse.y"
+  case 82:
+#line 1911 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list2((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 6198 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6371 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 75:
-#line 1843 "mrbgems/mruby-compiler/core/parse.y"
+  case 83:
+#line 1915 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3((yyvsp[-4].nd), (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 6206 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6379 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 76:
-#line 1847 "mrbgems/mruby-compiler/core/parse.y"
+  case 84:
+#line 1919 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list2((yyvsp[-1].nd), new_nil(p));
                     }
-#line 6214 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6387 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 77:
-#line 1851 "mrbgems/mruby-compiler/core/parse.y"
+  case 85:
+#line 1923 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3((yyvsp[-3].nd), new_nil(p), (yyvsp[0].nd));
                     }
-#line 6222 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6395 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 78:
-#line 1855 "mrbgems/mruby-compiler/core/parse.y"
+  case 86:
+#line 1927 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list2(0, (yyvsp[0].nd));
                     }
-#line 6230 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6403 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 79:
-#line 1859 "mrbgems/mruby-compiler/core/parse.y"
+  case 87:
+#line 1931 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3(0, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 6238 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6411 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 80:
-#line 1863 "mrbgems/mruby-compiler/core/parse.y"
+  case 88:
+#line 1935 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list2(0, new_nil(p));
                     }
-#line 6246 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6419 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 81:
-#line 1867 "mrbgems/mruby-compiler/core/parse.y"
+  case 89:
+#line 1939 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3(0, new_nil(p), (yyvsp[0].nd));
                     }
-#line 6254 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6427 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 83:
-#line 1874 "mrbgems/mruby-compiler/core/parse.y"
+  case 91:
+#line 1946 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_masgn(p, (yyvsp[-1].nd), NULL);
                     }
-#line 6262 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6435 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 84:
-#line 1880 "mrbgems/mruby-compiler/core/parse.y"
+  case 92:
+#line 1952 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[-1].nd));
                     }
-#line 6270 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6443 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 85:
-#line 1884 "mrbgems/mruby-compiler/core/parse.y"
+  case 93:
+#line 1956 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[-1].nd));
                     }
-#line 6278 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6451 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 86:
-#line 1890 "mrbgems/mruby-compiler/core/parse.y"
+  case 94:
+#line 1962 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 6286 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6459 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 87:
-#line 1894 "mrbgems/mruby-compiler/core/parse.y"
+  case 95:
+#line 1966 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 6294 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6467 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 88:
-#line 1900 "mrbgems/mruby-compiler/core/parse.y"
+  case 96:
+#line 1972 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       assignable(p, (yyvsp[0].nd));
                     }
-#line 6302 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6475 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 89:
-#line 1904 "mrbgems/mruby-compiler/core/parse.y"
+  case 97:
+#line 1976 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
+                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), MRB_QSYM(aref), (yyvsp[-1].nd), '.');
                     }
-#line 6310 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6483 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 90:
-#line 1908 "mrbgems/mruby-compiler/core/parse.y"
+  case 98:
+#line 1980 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
                     }
-#line 6318 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6491 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 91:
-#line 1912 "mrbgems/mruby-compiler/core/parse.y"
+  case 99:
+#line 1984 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
                     }
-#line 6326 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6499 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 92:
-#line 1916 "mrbgems/mruby-compiler/core/parse.y"
+  case 100:
+#line 1988 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
                     }
-#line 6334 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6507 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 93:
-#line 1920 "mrbgems/mruby-compiler/core/parse.y"
+  case 101:
+#line 1992 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if (p->in_def || p->in_single)
                         yyerror(p, "dynamic constant assignment");
                       (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
                     }
-#line 6344 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6517 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 94:
-#line 1926 "mrbgems/mruby-compiler/core/parse.y"
+  case 102:
+#line 1998 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if (p->in_def || p->in_single)
                         yyerror(p, "dynamic constant assignment");
                       (yyval.nd) = new_colon3(p, (yyvsp[0].id));
                     }
-#line 6354 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6527 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 95:
-#line 1932 "mrbgems/mruby-compiler/core/parse.y"
+  case 103:
+#line 2004 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       backref_error(p, (yyvsp[0].nd));
                       (yyval.nd) = 0;
                     }
-#line 6363 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6536 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 96:
-#line 1939 "mrbgems/mruby-compiler/core/parse.y"
+  case 104:
+#line 2011 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       assignable(p, (yyvsp[0].nd));
                     }
-#line 6371 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6544 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 97:
-#line 1943 "mrbgems/mruby-compiler/core/parse.y"
+  case 105:
+#line 2015 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
+                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), MRB_QSYM(aref), (yyvsp[-1].nd), '.');
                     }
-#line 6379 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6552 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 98:
-#line 1947 "mrbgems/mruby-compiler/core/parse.y"
+  case 106:
+#line 2019 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
                     }
-#line 6387 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6560 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 99:
-#line 1951 "mrbgems/mruby-compiler/core/parse.y"
+  case 107:
+#line 2023 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
                     }
-#line 6395 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6568 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 100:
-#line 1955 "mrbgems/mruby-compiler/core/parse.y"
+  case 108:
+#line 2027 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, (yyvsp[-1].num));
                     }
-#line 6403 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6576 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 101:
-#line 1959 "mrbgems/mruby-compiler/core/parse.y"
+  case 109:
+#line 2031 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if (p->in_def || p->in_single)
                         yyerror(p, "dynamic constant assignment");
                       (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
                     }
-#line 6413 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6586 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 102:
-#line 1965 "mrbgems/mruby-compiler/core/parse.y"
+  case 110:
+#line 2037 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if (p->in_def || p->in_single)
                         yyerror(p, "dynamic constant assignment");
                       (yyval.nd) = new_colon3(p, (yyvsp[0].id));
                     }
-#line 6423 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6596 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 103:
-#line 1971 "mrbgems/mruby-compiler/core/parse.y"
+  case 111:
+#line 2043 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       backref_error(p, (yyvsp[0].nd));
                       (yyval.nd) = 0;
                     }
-#line 6432 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6605 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 104:
-#line 1976 "mrbgems/mruby-compiler/core/parse.y"
+  case 112:
+#line 2048 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "can't assign to numbered parameter");
                     }
-#line 6440 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6613 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 105:
-#line 1982 "mrbgems/mruby-compiler/core/parse.y"
+  case 113:
+#line 2054 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "class/module name must be CONSTANT");
                     }
-#line 6448 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6621 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 107:
-#line 1989 "mrbgems/mruby-compiler/core/parse.y"
+  case 115:
+#line 2061 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons((node*)1, nsym((yyvsp[0].id)));
                     }
-#line 6456 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6629 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 108:
-#line 1993 "mrbgems/mruby-compiler/core/parse.y"
+  case 116:
+#line 2065 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons((node*)0, nsym((yyvsp[0].id)));
                     }
-#line 6464 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6637 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 109:
-#line 1997 "mrbgems/mruby-compiler/core/parse.y"
+  case 117:
+#line 2069 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[-2].nd));
                       (yyval.nd) = cons((yyvsp[-2].nd), nsym((yyvsp[0].id)));
                     }
-#line 6473 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6646 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 113:
-#line 2007 "mrbgems/mruby-compiler/core/parse.y"
+  case 121:
+#line 2079 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lstate = EXPR_ENDFN;
                       (yyval.id) = (yyvsp[0].id);
                     }
-#line 6482 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6655 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 114:
-#line 2012 "mrbgems/mruby-compiler/core/parse.y"
+  case 122:
+#line 2084 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lstate = EXPR_ENDFN;
                       (yyval.id) = (yyvsp[0].id);
                     }
-#line 6491 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6664 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 117:
-#line 2023 "mrbgems/mruby-compiler/core/parse.y"
+  case 125:
+#line 2095 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_undef(p, (yyvsp[0].id));
                     }
-#line 6499 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6672 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 118:
-#line 2026 "mrbgems/mruby-compiler/core/parse.y"
+  case 126:
+#line 2098 "mrbgems/mruby-compiler/core/parse.y"
                                  {p->lstate = EXPR_FNAME;}
-#line 6505 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6678 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 119:
-#line 2027 "mrbgems/mruby-compiler/core/parse.y"
+  case 127:
+#line 2099 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-3].nd), nsym((yyvsp[0].id)));
                     }
-#line 6513 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 120:
-#line 2032 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("|");   }
-#line 6519 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 121:
-#line 2033 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("^");   }
-#line 6525 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 122:
-#line 2034 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("&");   }
-#line 6531 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 123:
-#line 2035 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("<=>"); }
-#line 6537 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 124:
-#line 2036 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("==");  }
-#line 6543 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 125:
-#line 2037 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("==="); }
-#line 6549 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 126:
-#line 2038 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("=~");  }
-#line 6555 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 127:
-#line 2039 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("!~");  }
-#line 6561 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6686 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 128:
-#line 2040 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit(">");   }
-#line 6567 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2104 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(or);     }
+#line 6692 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 129:
-#line 2041 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit(">=");  }
-#line 6573 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2105 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(xor);    }
+#line 6698 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 130:
-#line 2042 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("<");   }
-#line 6579 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2106 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(and);    }
+#line 6704 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 131:
-#line 2043 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("<=");  }
-#line 6585 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2107 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(cmp);    }
+#line 6710 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 132:
-#line 2044 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("!=");  }
-#line 6591 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2108 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(eq);     }
+#line 6716 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 133:
-#line 2045 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("<<");  }
-#line 6597 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2109 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(eqq);    }
+#line 6722 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 134:
-#line 2046 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit(">>");  }
-#line 6603 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2110 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(match);  }
+#line 6728 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 135:
-#line 2047 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("+");   }
-#line 6609 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2111 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(nmatch); }
+#line 6734 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 136:
-#line 2048 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("-");   }
-#line 6615 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2112 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(gt);     }
+#line 6740 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 137:
-#line 2049 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("*");   }
-#line 6621 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2113 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(ge);     }
+#line 6746 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 138:
-#line 2050 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("*");   }
-#line 6627 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2114 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(lt);     }
+#line 6752 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 139:
-#line 2051 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("/");   }
-#line 6633 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2115 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(le);     }
+#line 6758 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 140:
-#line 2052 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("%");   }
-#line 6639 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2116 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(neq);    }
+#line 6764 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 141:
-#line 2053 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("**");  }
-#line 6645 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2117 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(lshift); }
+#line 6770 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 142:
-#line 2054 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("**");  }
-#line 6651 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2118 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(rshift); }
+#line 6776 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 143:
-#line 2055 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("!");   }
-#line 6657 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2119 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(add);    }
+#line 6782 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 144:
-#line 2056 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("~");   }
-#line 6663 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2120 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(sub);    }
+#line 6788 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 145:
-#line 2057 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("+@");  }
-#line 6669 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2121 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(mul);    }
+#line 6794 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 146:
-#line 2058 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("-@");  }
-#line 6675 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2122 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(mul);    }
+#line 6800 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 147:
-#line 2059 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("[]");  }
-#line 6681 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2123 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(div);    }
+#line 6806 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 148:
-#line 2060 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("[]="); }
-#line 6687 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2124 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(mod);    }
+#line 6812 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
   case 149:
-#line 2061 "mrbgems/mruby-compiler/core/parse.y"
-                                { (yyval.id) = intern_lit("`");   }
-#line 6693 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 2125 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(pow);    }
+#line 6818 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 190:
-#line 2079 "mrbgems/mruby-compiler/core/parse.y"
+  case 150:
+#line 2126 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(pow);    }
+#line 6824 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 151:
+#line 2127 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(not);    }
+#line 6830 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 152:
+#line 2128 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(neg);    }
+#line 6836 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 153:
+#line 2129 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(plus);   }
+#line 6842 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 154:
+#line 2130 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(minus);  }
+#line 6848 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 155:
+#line 2131 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(aref);   }
+#line 6854 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 156:
+#line 2132 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(aset);   }
+#line 6860 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 157:
+#line 2133 "mrbgems/mruby-compiler/core/parse.y"
+                                { (yyval.id) = MRB_QSYM(tick);   }
+#line 6866 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 198:
+#line 2151 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_asgn(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 6701 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6874 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 191:
-#line 2083 "mrbgems/mruby-compiler/core/parse.y"
+  case 199:
+#line 2155 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_op_asgn(p, (yyvsp[-2].nd), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 6709 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6882 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 192:
-#line 2087 "mrbgems/mruby-compiler/core/parse.y"
+  case 200:
+#line 2159 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), intern_lit("[]"), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
+                      (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-5].nd), MRB_QSYM(aref), (yyvsp[-3].nd), '.'), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 6717 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6890 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 193:
-#line 2091 "mrbgems/mruby-compiler/core/parse.y"
+  case 201:
+#line 2163 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 6725 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6898 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 194:
-#line 2095 "mrbgems/mruby-compiler/core/parse.y"
+  case 202:
+#line 2167 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, (yyvsp[-3].num)), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 6733 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6906 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 195:
-#line 2099 "mrbgems/mruby-compiler/core/parse.y"
+  case 203:
+#line 2171 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_op_asgn(p, new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), 0, tCOLON2), (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 6741 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6914 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 196:
-#line 2103 "mrbgems/mruby-compiler/core/parse.y"
+  case 204:
+#line 2175 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "constant re-assignment");
                       (yyval.nd) = new_begin(p, 0);
                     }
-#line 6750 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6923 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 197:
-#line 2108 "mrbgems/mruby-compiler/core/parse.y"
+  case 205:
+#line 2180 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "constant re-assignment");
                       (yyval.nd) = new_begin(p, 0);
                     }
-#line 6759 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6932 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 198:
-#line 2113 "mrbgems/mruby-compiler/core/parse.y"
+  case 206:
+#line 2185 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       backref_error(p, (yyvsp[-2].nd));
                       (yyval.nd) = new_begin(p, 0);
                     }
-#line 6768 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6941 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 199:
-#line 2118 "mrbgems/mruby-compiler/core/parse.y"
+  case 207:
+#line 2190 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_dot2(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 6776 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6949 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 200:
-#line 2122 "mrbgems/mruby-compiler/core/parse.y"
+  case 208:
+#line 2194 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_dot3(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 6784 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6957 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 201:
-#line 2126 "mrbgems/mruby-compiler/core/parse.y"
+  case 209:
+#line 2198 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "+", (yyvsp[0].nd));
                     }
-#line 6792 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6965 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 202:
-#line 2130 "mrbgems/mruby-compiler/core/parse.y"
+  case 210:
+#line 2202 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "-", (yyvsp[0].nd));
                     }
-#line 6800 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6973 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 203:
-#line 2134 "mrbgems/mruby-compiler/core/parse.y"
+  case 211:
+#line 2206 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "*", (yyvsp[0].nd));
                     }
-#line 6808 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6981 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 204:
-#line 2138 "mrbgems/mruby-compiler/core/parse.y"
+  case 212:
+#line 2210 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "/", (yyvsp[0].nd));
                     }
-#line 6816 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6989 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 205:
-#line 2142 "mrbgems/mruby-compiler/core/parse.y"
+  case 213:
+#line 2214 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "%", (yyvsp[0].nd));
                     }
-#line 6824 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 6997 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 206:
-#line 2146 "mrbgems/mruby-compiler/core/parse.y"
+  case 214:
+#line 2218 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd));
                     }
-#line 6832 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7005 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 207:
-#line 2150 "mrbgems/mruby-compiler/core/parse.y"
+  case 215:
+#line 2222 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)), "-@");
                     }
-#line 6840 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7013 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 208:
-#line 2154 "mrbgems/mruby-compiler/core/parse.y"
+  case 216:
+#line 2226 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, call_bin_op(p, (yyvsp[-2].nd), "**", (yyvsp[0].nd)), "-@");
                     }
-#line 6848 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7021 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 209:
-#line 2158 "mrbgems/mruby-compiler/core/parse.y"
+  case 217:
+#line 2230 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "+@");
                     }
-#line 6856 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7029 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 210:
-#line 2162 "mrbgems/mruby-compiler/core/parse.y"
+  case 218:
+#line 2234 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, (yyvsp[0].nd), "-@");
                     }
-#line 6864 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7037 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 211:
-#line 2166 "mrbgems/mruby-compiler/core/parse.y"
+  case 219:
+#line 2238 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "|", (yyvsp[0].nd));
                     }
-#line 6872 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7045 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 212:
-#line 2170 "mrbgems/mruby-compiler/core/parse.y"
+  case 220:
+#line 2242 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "^", (yyvsp[0].nd));
                     }
-#line 6880 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7053 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 213:
-#line 2174 "mrbgems/mruby-compiler/core/parse.y"
+  case 221:
+#line 2246 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "&", (yyvsp[0].nd));
                     }
-#line 6888 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7061 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 214:
-#line 2178 "mrbgems/mruby-compiler/core/parse.y"
+  case 222:
+#line 2250 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=>", (yyvsp[0].nd));
                     }
-#line 6896 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7069 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 215:
-#line 2182 "mrbgems/mruby-compiler/core/parse.y"
+  case 223:
+#line 2254 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">", (yyvsp[0].nd));
                     }
-#line 6904 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7077 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 216:
-#line 2186 "mrbgems/mruby-compiler/core/parse.y"
+  case 224:
+#line 2258 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">=", (yyvsp[0].nd));
                     }
-#line 6912 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7085 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 217:
-#line 2190 "mrbgems/mruby-compiler/core/parse.y"
+  case 225:
+#line 2262 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<", (yyvsp[0].nd));
                     }
-#line 6920 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7093 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 218:
-#line 2194 "mrbgems/mruby-compiler/core/parse.y"
+  case 226:
+#line 2266 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<=", (yyvsp[0].nd));
                     }
-#line 6928 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7101 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 219:
-#line 2198 "mrbgems/mruby-compiler/core/parse.y"
+  case 227:
+#line 2270 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "==", (yyvsp[0].nd));
                     }
-#line 6936 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7109 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 220:
-#line 2202 "mrbgems/mruby-compiler/core/parse.y"
+  case 228:
+#line 2274 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "===", (yyvsp[0].nd));
                     }
-#line 6944 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7117 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 221:
-#line 2206 "mrbgems/mruby-compiler/core/parse.y"
+  case 229:
+#line 2278 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!=", (yyvsp[0].nd));
                     }
-#line 6952 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7125 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 222:
-#line 2210 "mrbgems/mruby-compiler/core/parse.y"
+  case 230:
+#line 2282 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "=~", (yyvsp[0].nd));
                     }
-#line 6960 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7133 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 223:
-#line 2214 "mrbgems/mruby-compiler/core/parse.y"
+  case 231:
+#line 2286 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "!~", (yyvsp[0].nd));
                     }
-#line 6968 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7141 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 224:
-#line 2218 "mrbgems/mruby-compiler/core/parse.y"
+  case 232:
+#line 2290 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "!");
                     }
-#line 6976 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7149 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 225:
-#line 2222 "mrbgems/mruby-compiler/core/parse.y"
+  case 233:
+#line 2294 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, cond((yyvsp[0].nd)), "~");
                     }
-#line 6984 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7157 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 226:
-#line 2226 "mrbgems/mruby-compiler/core/parse.y"
+  case 234:
+#line 2298 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), "<<", (yyvsp[0].nd));
                     }
-#line 6992 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7165 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 227:
-#line 2230 "mrbgems/mruby-compiler/core/parse.y"
+  case 235:
+#line 2302 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_bin_op(p, (yyvsp[-2].nd), ">>", (yyvsp[0].nd));
                     }
-#line 7000 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7173 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 228:
-#line 2234 "mrbgems/mruby-compiler/core/parse.y"
+  case 236:
+#line 2306 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_and(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 7008 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7181 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 229:
-#line 2238 "mrbgems/mruby-compiler/core/parse.y"
+  case 237:
+#line 2310 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_or(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 7016 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7189 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 230:
-#line 2242 "mrbgems/mruby-compiler/core/parse.y"
+  case 238:
+#line 2314 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
                     }
-#line 7024 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7197 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 231:
-#line 2246 "mrbgems/mruby-compiler/core/parse.y"
+  case 239:
+#line 2318 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_if(p, cond((yyvsp[-5].nd)), (yyvsp[-3].nd), (yyvsp[0].nd));
                     }
-#line 7032 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7205 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 232:
-#line 2250 "mrbgems/mruby-compiler/core/parse.y"
+  case 240:
+#line 2322 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      (yyval.nd) = (yyvsp[-3].nd);
+                      void_expr_error(p, (yyvsp[0].nd));
+                      defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
+                      nvars_unnest(p);
+                      p->in_def--;
+                    }
+#line 7217 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 241:
+#line 2330 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      (yyval.nd) = (yyvsp[-5].nd);
+                      void_expr_error(p, (yyvsp[-2].nd));
+                      void_expr_error(p, (yyvsp[0].nd));
+                      defn_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
+                      nvars_unnest(p);
+                      p->in_def--;
+                    }
+#line 7230 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 242:
+#line 2339 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      (yyval.nd) = (yyvsp[-3].nd);
+                      void_expr_error(p, (yyvsp[0].nd));
+                      defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[0].nd));
+                      nvars_unnest(p);
+                      p->in_def--;
+                      p->in_single--;
+                    }
+#line 7243 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 243:
+#line 2348 "mrbgems/mruby-compiler/core/parse.y"
+                    {
+                      (yyval.nd) = (yyvsp[-5].nd);
+                      void_expr_error(p, (yyvsp[-2].nd));
+                      void_expr_error(p, (yyvsp[0].nd));
+                      defs_setup(p, (yyval.nd), (yyvsp[-4].nd), new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd)));
+                      nvars_unnest(p);
+                      p->in_def--;
+                      p->in_single--;
+                    }
+#line 7257 "mrbgems/mruby-compiler/core/y.tab.c"
+    break;
+
+  case 244:
+#line 2358 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 7040 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7265 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 234:
-#line 2257 "mrbgems/mruby-compiler/core/parse.y"
+  case 246:
+#line 2365 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                       NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
                     }
-#line 7049 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7274 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 235:
-#line 2262 "mrbgems/mruby-compiler/core/parse.y"
+  case 247:
+#line 2370 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd)));
                     }
-#line 7057 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7282 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 236:
-#line 2266 "mrbgems/mruby-compiler/core/parse.y"
+  case 248:
+#line 2374 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons(new_kw_hash(p, (yyvsp[-1].nd)), 0);
                       NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
                     }
-#line 7066 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7291 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 237:
-#line 2273 "mrbgems/mruby-compiler/core/parse.y"
+  case 249:
+#line 2381 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 7074 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7299 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 238:
-#line 2277 "mrbgems/mruby-compiler/core/parse.y"
+  case 250:
+#line 2385 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[-2].nd));
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = new_mod_rescue(p, (yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 7084 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7309 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 239:
-#line 2285 "mrbgems/mruby-compiler/core/parse.y"
+  case 251:
+#line 2393 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 7092 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7317 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 240:
-#line 2289 "mrbgems/mruby-compiler/core/parse.y"
+  case 252:
+#line 2397 "mrbgems/mruby-compiler/core/parse.y"
                     {
 #if 1
-                      mrb_sym r = mrb_intern_lit(p->mrb, "*");
-                      mrb_sym b = mrb_intern_lit(p->mrb, "&");
+                      mrb_sym r = MRB_QSYM(mul);
+                      mrb_sym b = MRB_QSYM(and);
                       if (local_var_p(p, r)  && local_var_p(p, b)) {
                         (yyval.nd) = cons(list1(new_splat(p, new_lvar(p, r))),
                                   new_block_arg(p, new_lvar(p, b)));
                       }
 #else
-                      mrb_sym r = mrb_intern_lit(p->mrb, "*");
-                      mrb_sym k = mrb_intern_lit(p->mrb, "**");
-                      mrb_sym b = mrb_intern_lit(p->mrb, "&");
+                      mrb_sym r = MRB_QSYM(mul);
+                      mrb_sym k = MRB_QSYM(pow);
+                      mrb_sym b = MRB_QSYM(and);
                       if (local_var_p(p, r) && local_var_p(p, k) && local_var_p(p, b)) {
                         (yyval.nd) = cons(list2(new_splat(p, new_lvar(p, r)),
                                         new_kw_hash(p, list1(cons(new_kw_rest_args(p, 0), new_lvar(p, k))))),
@@ -7116,373 +7341,373 @@ yyreduce:
                         (yyval.nd) = 0;
                       }
                     }
-#line 7120 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7345 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 245:
-#line 2321 "mrbgems/mruby-compiler/core/parse.y"
+  case 257:
+#line 2429 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons((yyvsp[-1].nd),0);
                       NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
                     }
-#line 7129 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7354 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 246:
-#line 2326 "mrbgems/mruby-compiler/core/parse.y"
+  case 258:
+#line 2434 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons(push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd))), 0);
                       NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
                     }
-#line 7138 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7363 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 247:
-#line 2331 "mrbgems/mruby-compiler/core/parse.y"
+  case 259:
+#line 2439 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons(list1(new_kw_hash(p, (yyvsp[-1].nd))), 0);
                       NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
                     }
-#line 7147 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7372 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 248:
-#line 2338 "mrbgems/mruby-compiler/core/parse.y"
+  case 260:
+#line 2446 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = cons(list1((yyvsp[0].nd)), 0);
                       NODE_LINENO((yyval.nd), (yyvsp[0].nd));
                     }
-#line 7157 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7382 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 249:
-#line 2344 "mrbgems/mruby-compiler/core/parse.y"
+  case 261:
+#line 2452 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons((yyvsp[-1].nd), (yyvsp[0].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
                     }
-#line 7166 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7391 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 250:
-#line 2349 "mrbgems/mruby-compiler/core/parse.y"
+  case 262:
+#line 2457 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons(list1(new_kw_hash(p, (yyvsp[-1].nd))), (yyvsp[0].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
                     }
-#line 7175 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7400 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 251:
-#line 2354 "mrbgems/mruby-compiler/core/parse.y"
+  case 263:
+#line 2462 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons(push((yyvsp[-3].nd), new_kw_hash(p, (yyvsp[-1].nd))), (yyvsp[0].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[-3].nd));
                     }
-#line 7184 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7409 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 252:
-#line 2359 "mrbgems/mruby-compiler/core/parse.y"
+  case 264:
+#line 2467 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons(0, (yyvsp[0].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[0].nd));
                     }
-#line 7193 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7418 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 253:
-#line 2365 "mrbgems/mruby-compiler/core/parse.y"
+  case 265:
+#line 2473 "mrbgems/mruby-compiler/core/parse.y"
                    {
                       (yyval.stack) = p->cmdarg_stack;
                       CMDARG_PUSH(1);
                     }
-#line 7202 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7427 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 254:
-#line 2370 "mrbgems/mruby-compiler/core/parse.y"
+  case 266:
+#line 2478 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->cmdarg_stack = (yyvsp[-1].stack);
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 7211 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7436 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 255:
-#line 2377 "mrbgems/mruby-compiler/core/parse.y"
+  case 267:
+#line 2485 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_block_arg(p, (yyvsp[0].nd));
                     }
-#line 7219 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7444 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 256:
-#line 2383 "mrbgems/mruby-compiler/core/parse.y"
+  case 268:
+#line 2491 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 7227 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7452 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 257:
-#line 2387 "mrbgems/mruby-compiler/core/parse.y"
+  case 269:
+#line 2495 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = 0;
                     }
-#line 7235 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7460 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 260:
-#line 2397 "mrbgems/mruby-compiler/core/parse.y"
+  case 272:
+#line 2505 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = cons((yyvsp[0].nd), 0);
                       NODE_LINENO((yyval.nd), (yyvsp[0].nd));
                     }
-#line 7245 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7470 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 261:
-#line 2403 "mrbgems/mruby-compiler/core/parse.y"
+  case 273:
+#line 2511 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = cons(new_splat(p, (yyvsp[0].nd)), 0);
                       NODE_LINENO((yyval.nd), (yyvsp[0].nd));
                     }
-#line 7255 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7480 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 262:
-#line 2409 "mrbgems/mruby-compiler/core/parse.y"
+  case 274:
+#line 2517 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 7264 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7489 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 263:
-#line 2414 "mrbgems/mruby-compiler/core/parse.y"
+  case 275:
+#line 2522 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
                     }
-#line 7273 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7498 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 264:
-#line 2421 "mrbgems/mruby-compiler/core/parse.y"
+  case 276:
+#line 2529 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 7282 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7507 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 265:
-#line 2426 "mrbgems/mruby-compiler/core/parse.y"
+  case 277:
+#line 2534 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = push((yyvsp[-3].nd), new_splat(p, (yyvsp[0].nd)));
                     }
-#line 7291 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7516 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 266:
-#line 2431 "mrbgems/mruby-compiler/core/parse.y"
+  case 278:
+#line 2539 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = list1(new_splat(p, (yyvsp[0].nd)));
                     }
-#line 7300 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7525 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 274:
-#line 2445 "mrbgems/mruby-compiler/core/parse.y"
+  case 286:
+#line 2553 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_nvar(p, (yyvsp[0].num));
                     }
-#line 7308 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7533 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 275:
-#line 2449 "mrbgems/mruby-compiler/core/parse.y"
+  case 287:
+#line 2557 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_fcall(p, (yyvsp[0].id), 0);
                     }
-#line 7316 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7541 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 276:
-#line 2453 "mrbgems/mruby-compiler/core/parse.y"
+  case 288:
+#line 2561 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.stack) = p->cmdarg_stack;
                       p->cmdarg_stack = 0;
                     }
-#line 7325 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7550 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 277:
-#line 2459 "mrbgems/mruby-compiler/core/parse.y"
+  case 289:
+#line 2567 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->cmdarg_stack = (yyvsp[-2].stack);
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 7334 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7559 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 278:
-#line 2464 "mrbgems/mruby-compiler/core/parse.y"
+  case 290:
+#line 2572 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.stack) = p->cmdarg_stack;
                       p->cmdarg_stack = 0;
                     }
-#line 7343 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7568 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 279:
-#line 2468 "mrbgems/mruby-compiler/core/parse.y"
+  case 291:
+#line 2576 "mrbgems/mruby-compiler/core/parse.y"
                        {p->lstate = EXPR_ENDARG;}
-#line 7349 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7574 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 280:
-#line 2469 "mrbgems/mruby-compiler/core/parse.y"
+  case 292:
+#line 2577 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->cmdarg_stack = (yyvsp[-3].stack);
                       (yyval.nd) = (yyvsp[-2].nd);
                     }
-#line 7358 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7583 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 281:
-#line 2473 "mrbgems/mruby-compiler/core/parse.y"
+  case 293:
+#line 2581 "mrbgems/mruby-compiler/core/parse.y"
                               {p->lstate = EXPR_ENDARG;}
-#line 7364 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7589 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 282:
-#line 2474 "mrbgems/mruby-compiler/core/parse.y"
+  case 294:
+#line 2582 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_nil(p);
                     }
-#line 7372 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7597 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 283:
-#line 2478 "mrbgems/mruby-compiler/core/parse.y"
+  case 295:
+#line 2586 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 7380 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7605 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 284:
-#line 2482 "mrbgems/mruby-compiler/core/parse.y"
+  case 296:
+#line 2590 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_colon2(p, (yyvsp[-2].nd), (yyvsp[0].id));
                     }
-#line 7388 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7613 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 285:
-#line 2486 "mrbgems/mruby-compiler/core/parse.y"
+  case 297:
+#line 2594 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_colon3(p, (yyvsp[0].id));
                     }
-#line 7396 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7621 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 286:
-#line 2490 "mrbgems/mruby-compiler/core/parse.y"
+  case 298:
+#line 2598 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_array(p, (yyvsp[-1].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
                     }
-#line 7405 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7630 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 287:
-#line 2495 "mrbgems/mruby-compiler/core/parse.y"
+  case 299:
+#line 2603 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_hash(p, (yyvsp[-1].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[-1].nd));
                     }
-#line 7414 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7639 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 288:
-#line 2500 "mrbgems/mruby-compiler/core/parse.y"
+  case 300:
+#line 2608 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_return(p, 0);
                     }
-#line 7422 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7647 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 289:
-#line 2504 "mrbgems/mruby-compiler/core/parse.y"
+  case 301:
+#line 2612 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_yield(p, (yyvsp[0].nd));
                     }
-#line 7430 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7655 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 290:
-#line 2508 "mrbgems/mruby-compiler/core/parse.y"
+  case 302:
+#line 2616 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, cond((yyvsp[-1].nd)), "!");
                     }
-#line 7438 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7663 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 291:
-#line 2512 "mrbgems/mruby-compiler/core/parse.y"
+  case 303:
+#line 2620 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = call_uni_op(p, new_nil(p), "!");
                     }
-#line 7446 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7671 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 292:
-#line 2516 "mrbgems/mruby-compiler/core/parse.y"
+  case 304:
+#line 2624 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_fcall(p, (yyvsp[-1].id), cons(0, (yyvsp[0].nd)));
                     }
-#line 7454 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7679 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 294:
-#line 2521 "mrbgems/mruby-compiler/core/parse.y"
+  case 306:
+#line 2629 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       call_with_block(p, (yyvsp[-1].nd), (yyvsp[0].nd));
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 7463 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7688 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 295:
-#line 2526 "mrbgems/mruby-compiler/core/parse.y"
+  case 307:
+#line 2634 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_nest(p);
                       (yyval.num) = p->lpar_beg;
                       p->lpar_beg = ++p->paren_nest;
                     }
-#line 7473 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7698 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 296:
-#line 2532 "mrbgems/mruby-compiler/core/parse.y"
+  case 308:
+#line 2640 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.stack) = p->cmdarg_stack;
                       p->cmdarg_stack = 0;
                     }
-#line 7482 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7707 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 297:
-#line 2537 "mrbgems/mruby-compiler/core/parse.y"
+  case 309:
+#line 2645 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lpar_beg = (yyvsp[-3].num);
                       (yyval.nd) = new_lambda(p, (yyvsp[-2].nd), (yyvsp[0].nd));
@@ -7490,149 +7715,149 @@ yyreduce:
                       p->cmdarg_stack = (yyvsp[-1].stack);
                       CMDARG_LEXPOP();
                     }
-#line 7494 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7719 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 298:
-#line 2548 "mrbgems/mruby-compiler/core/parse.y"
+  case 310:
+#line 2656 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_if(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-5].num));
                     }
-#line 7503 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7728 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 299:
-#line 2556 "mrbgems/mruby-compiler/core/parse.y"
+  case 311:
+#line 2664 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_unless(p, cond((yyvsp[-4].nd)), (yyvsp[-2].nd), (yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-5].num));
                     }
-#line 7512 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7737 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 300:
-#line 2560 "mrbgems/mruby-compiler/core/parse.y"
+  case 312:
+#line 2668 "mrbgems/mruby-compiler/core/parse.y"
                                 {COND_PUSH(1);}
-#line 7518 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7743 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 301:
-#line 2560 "mrbgems/mruby-compiler/core/parse.y"
+  case 313:
+#line 2668 "mrbgems/mruby-compiler/core/parse.y"
                                                               {COND_POP();}
-#line 7524 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7749 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 302:
-#line 2563 "mrbgems/mruby-compiler/core/parse.y"
+  case 314:
+#line 2671 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_while(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-6].num));
                     }
-#line 7533 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7758 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 303:
-#line 2567 "mrbgems/mruby-compiler/core/parse.y"
+  case 315:
+#line 2675 "mrbgems/mruby-compiler/core/parse.y"
                                 {COND_PUSH(1);}
-#line 7539 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7764 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 304:
-#line 2567 "mrbgems/mruby-compiler/core/parse.y"
+  case 316:
+#line 2675 "mrbgems/mruby-compiler/core/parse.y"
                                                               {COND_POP();}
-#line 7545 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7770 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 305:
-#line 2570 "mrbgems/mruby-compiler/core/parse.y"
+  case 317:
+#line 2678 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_until(p, cond((yyvsp[-4].nd)), (yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-6].num));
                     }
-#line 7554 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7779 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 306:
-#line 2577 "mrbgems/mruby-compiler/core/parse.y"
+  case 318:
+#line 2685 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_case(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
                     }
-#line 7562 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7787 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 307:
-#line 2581 "mrbgems/mruby-compiler/core/parse.y"
+  case 319:
+#line 2689 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_case(p, 0, (yyvsp[-1].nd));
                     }
-#line 7570 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7795 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 308:
-#line 2585 "mrbgems/mruby-compiler/core/parse.y"
+  case 320:
+#line 2693 "mrbgems/mruby-compiler/core/parse.y"
                   {COND_PUSH(1);}
-#line 7576 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7801 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 309:
-#line 2587 "mrbgems/mruby-compiler/core/parse.y"
+  case 321:
+#line 2695 "mrbgems/mruby-compiler/core/parse.y"
                   {COND_POP();}
-#line 7582 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7807 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 310:
-#line 2590 "mrbgems/mruby-compiler/core/parse.y"
+  case 322:
+#line 2698 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_for(p, (yyvsp[-7].nd), (yyvsp[-4].nd), (yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-8].num));
                     }
-#line 7591 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7816 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 311:
-#line 2596 "mrbgems/mruby-compiler/core/parse.y"
+  case 323:
+#line 2704 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if (p->in_def || p->in_single)
                         yyerror(p, "class definition in method body");
                       (yyval.nd) = local_switch(p);
                       nvars_block(p);
                     }
-#line 7602 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7827 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 312:
-#line 2604 "mrbgems/mruby-compiler/core/parse.y"
+  case 324:
+#line 2712 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_class(p, (yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-5].num));
                       local_resume(p, (yyvsp[-2].nd));
                       nvars_unnest(p);
                     }
-#line 7613 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7838 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 313:
-#line 2612 "mrbgems/mruby-compiler/core/parse.y"
+  case 325:
+#line 2720 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.num) = p->in_def;
                       p->in_def = 0;
                     }
-#line 7622 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7847 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 314:
-#line 2617 "mrbgems/mruby-compiler/core/parse.y"
+  case 326:
+#line 2725 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons(local_switch(p), nint(p->in_single));
                       nvars_block(p);
                       p->in_single = 0;
                     }
-#line 7632 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7857 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 315:
-#line 2624 "mrbgems/mruby-compiler/core/parse.y"
+  case 327:
+#line 2732 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_sclass(p, (yyvsp[-5].nd), (yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-7].num));
@@ -7641,539 +7866,496 @@ yyreduce:
                       p->in_def = (yyvsp[-4].num);
                       p->in_single = intn((yyvsp[-2].nd)->cdr);
                     }
-#line 7645 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7870 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 316:
-#line 2634 "mrbgems/mruby-compiler/core/parse.y"
+  case 328:
+#line 2742 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if (p->in_def || p->in_single)
                         yyerror(p, "module definition in method body");
                       (yyval.nd) = local_switch(p);
                       nvars_block(p);
                     }
-#line 7656 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7881 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 317:
-#line 2642 "mrbgems/mruby-compiler/core/parse.y"
+  case 329:
+#line 2750 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_module(p, (yyvsp[-3].nd), (yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-4].num));
                       local_resume(p, (yyvsp[-2].nd));
                       nvars_unnest(p);
                     }
-#line 7667 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 318:
-#line 2649 "mrbgems/mruby-compiler/core/parse.y"
-                    {
-                      (yyval.stack) = p->cmdarg_stack;
-                      p->cmdarg_stack = 0;
-                    }
-#line 7676 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7892 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 319:
-#line 2653 "mrbgems/mruby-compiler/core/parse.y"
+  case 330:
+#line 2760 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      p->in_def++;
-                      (yyval.nd) = local_switch(p);
-                      nvars_block(p);
-                    }
-#line 7686 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 320:
-#line 2661 "mrbgems/mruby-compiler/core/parse.y"
-                    {
-                      (yyval.nd) = new_def(p, (yyvsp[-5].id), (yyvsp[-2].nd), (yyvsp[-1].nd));
-                      SET_LINENO((yyval.nd), (yyvsp[-6].num));
-                      local_resume(p, (yyvsp[-3].nd));
+                      (yyval.nd) = (yyvsp[-3].nd);
+                      defn_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
                       nvars_unnest(p);
                       p->in_def--;
-                      p->cmdarg_stack = (yyvsp[-4].stack);
                     }
-#line 7699 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7903 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 321:
-#line 2670 "mrbgems/mruby-compiler/core/parse.y"
+  case 331:
+#line 2770 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      p->lstate = EXPR_FNAME;
-                      (yyval.stack) = p->cmdarg_stack;
-                      p->cmdarg_stack = 0;
-                    }
-#line 7709 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 322:
-#line 2676 "mrbgems/mruby-compiler/core/parse.y"
-                    {
-                      p->in_single++;
-                      p->lstate = EXPR_ENDFN; /* force for args */
-                      (yyval.nd) = local_switch(p);
-                      nvars_block(p);
-                    }
-#line 7720 "mrbgems/mruby-compiler/core/y.tab.c"
-    break;
-
-  case 323:
-#line 2685 "mrbgems/mruby-compiler/core/parse.y"
-                    {
-                      (yyval.nd) = new_sdef(p, (yyvsp[-7].nd), (yyvsp[-4].id), (yyvsp[-2].nd), (yyvsp[-1].nd));
-                      SET_LINENO((yyval.nd), (yyvsp[-8].num));
-                      local_resume(p, (yyvsp[-3].nd));
+                      (yyval.nd) = (yyvsp[-3].nd);
+                      defs_setup(p, (yyval.nd), (yyvsp[-2].nd), (yyvsp[-1].nd));
                       nvars_unnest(p);
+                      p->in_def--;
                       p->in_single--;
-                      p->cmdarg_stack = (yyvsp[-5].stack);
                     }
-#line 7733 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7915 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 324:
-#line 2694 "mrbgems/mruby-compiler/core/parse.y"
+  case 332:
+#line 2778 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_break(p, 0);
                     }
-#line 7741 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7923 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 325:
-#line 2698 "mrbgems/mruby-compiler/core/parse.y"
+  case 333:
+#line 2782 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_next(p, 0);
                     }
-#line 7749 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7931 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 326:
-#line 2702 "mrbgems/mruby-compiler/core/parse.y"
+  case 334:
+#line 2786 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_redo(p);
                     }
-#line 7757 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7939 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 327:
-#line 2706 "mrbgems/mruby-compiler/core/parse.y"
+  case 335:
+#line 2790 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_retry(p);
                     }
-#line 7765 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7947 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 328:
-#line 2712 "mrbgems/mruby-compiler/core/parse.y"
+  case 336:
+#line 2796 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                       if (!(yyval.nd)) (yyval.nd) = new_nil(p);
                     }
-#line 7774 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7956 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 335:
-#line 2731 "mrbgems/mruby-compiler/core/parse.y"
+  case 343:
+#line 2815 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_if(p, cond((yyvsp[-3].nd)), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 7782 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7964 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 337:
-#line 2738 "mrbgems/mruby-compiler/core/parse.y"
+  case 345:
+#line 2822 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 7790 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7972 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 338:
-#line 2744 "mrbgems/mruby-compiler/core/parse.y"
+  case 346:
+#line 2828 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1(list1((yyvsp[0].nd)));
                     }
-#line 7798 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7980 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 340:
-#line 2751 "mrbgems/mruby-compiler/core/parse.y"
+  case 348:
+#line 2835 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3((yyvsp[0].nd),0,0);
                     }
-#line 7806 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7988 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 341:
-#line 2755 "mrbgems/mruby-compiler/core/parse.y"
+  case 349:
+#line 2839 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3((yyvsp[-3].nd), new_arg(p, (yyvsp[0].id)), 0);
                     }
-#line 7814 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 7996 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 342:
-#line 2759 "mrbgems/mruby-compiler/core/parse.y"
+  case 350:
+#line 2843 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3((yyvsp[-5].nd), new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
                     }
-#line 7822 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8004 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 343:
-#line 2763 "mrbgems/mruby-compiler/core/parse.y"
+  case 351:
+#line 2847 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_f(p, 0);
                       (yyval.nd) = list3((yyvsp[-2].nd), (node*)-1, 0);
                     }
-#line 7831 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8013 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 344:
-#line 2768 "mrbgems/mruby-compiler/core/parse.y"
+  case 352:
+#line 2852 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3((yyvsp[-4].nd), (node*)-1, (yyvsp[0].nd));
                     }
-#line 7839 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8021 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 345:
-#line 2772 "mrbgems/mruby-compiler/core/parse.y"
+  case 353:
+#line 2856 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3(0, new_arg(p, (yyvsp[0].id)), 0);
                     }
-#line 7847 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8029 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 346:
-#line 2776 "mrbgems/mruby-compiler/core/parse.y"
+  case 354:
+#line 2860 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3(0, new_arg(p, (yyvsp[-2].id)), (yyvsp[0].nd));
                     }
-#line 7855 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8037 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 347:
-#line 2780 "mrbgems/mruby-compiler/core/parse.y"
+  case 355:
+#line 2864 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_f(p, 0);
                       (yyval.nd) = list3(0, (node*)-1, 0);
                     }
-#line 7864 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8046 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 348:
-#line 2785 "mrbgems/mruby-compiler/core/parse.y"
+  case 356:
+#line 2869 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_f(p, 0);
                     }
-#line 7872 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8054 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 349:
-#line 2789 "mrbgems/mruby-compiler/core/parse.y"
+  case 357:
+#line 2873 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list3(0, (node*)-1, (yyvsp[0].nd));
                     }
-#line 7880 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8062 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 350:
-#line 2795 "mrbgems/mruby-compiler/core/parse.y"
+  case 358:
+#line 2879 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
                     }
-#line 7888 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8070 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 351:
-#line 2799 "mrbgems/mruby-compiler/core/parse.y"
+  case 359:
+#line 2883 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
                     }
-#line 7896 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8078 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 352:
-#line 2803 "mrbgems/mruby-compiler/core/parse.y"
+  case 360:
+#line 2887 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
                     }
-#line 7904 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8086 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 353:
-#line 2807 "mrbgems/mruby-compiler/core/parse.y"
+  case 361:
+#line 2891 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
                     }
-#line 7912 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8094 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 354:
-#line 2813 "mrbgems/mruby-compiler/core/parse.y"
+  case 362:
+#line 2897 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 7920 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8102 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 355:
-#line 2817 "mrbgems/mruby-compiler/core/parse.y"
+  case 363:
+#line 2901 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, 0, 0, 0);
                     }
-#line 7928 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8110 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 356:
-#line 2823 "mrbgems/mruby-compiler/core/parse.y"
+  case 364:
+#line 2907 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
                     }
-#line 7936 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8118 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 357:
-#line 2827 "mrbgems/mruby-compiler/core/parse.y"
+  case 365:
+#line 2911 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 7944 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8126 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 358:
-#line 2831 "mrbgems/mruby-compiler/core/parse.y"
+  case 366:
+#line 2915 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
                     }
-#line 7952 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8134 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 359:
-#line 2835 "mrbgems/mruby-compiler/core/parse.y"
+  case 367:
+#line 2919 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 7960 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8142 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 360:
-#line 2839 "mrbgems/mruby-compiler/core/parse.y"
+  case 368:
+#line 2923 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
                     }
-#line 7968 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8150 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 361:
-#line 2843 "mrbgems/mruby-compiler/core/parse.y"
+  case 369:
+#line 2927 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-2].nd), 0, 0, 0, (yyvsp[0].nd));
                     }
-#line 7976 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8158 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 362:
-#line 2847 "mrbgems/mruby-compiler/core/parse.y"
+  case 370:
+#line 2931 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 7984 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8166 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 363:
-#line 2851 "mrbgems/mruby-compiler/core/parse.y"
+  case 371:
+#line 2935 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
                     }
-#line 7992 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8174 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 364:
-#line 2855 "mrbgems/mruby-compiler/core/parse.y"
+  case 372:
+#line 2939 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
                     }
-#line 8000 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8182 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 365:
-#line 2859 "mrbgems/mruby-compiler/core/parse.y"
+  case 373:
+#line 2943 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 8008 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8190 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 366:
-#line 2863 "mrbgems/mruby-compiler/core/parse.y"
+  case 374:
+#line 2947 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
                     }
-#line 8016 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8198 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 367:
-#line 2867 "mrbgems/mruby-compiler/core/parse.y"
+  case 375:
+#line 2951 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 8024 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8206 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 368:
-#line 2871 "mrbgems/mruby-compiler/core/parse.y"
+  case 376:
+#line 2955 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
                     }
-#line 8032 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8214 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 369:
-#line 2875 "mrbgems/mruby-compiler/core/parse.y"
+  case 377:
+#line 2959 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 8040 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8222 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 370:
-#line 2879 "mrbgems/mruby-compiler/core/parse.y"
+  case 378:
+#line 2963 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
                     }
-#line 8048 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8230 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 371:
-#line 2885 "mrbgems/mruby-compiler/core/parse.y"
+  case 379:
+#line 2969 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_blk(p, 0);
                       (yyval.nd) = 0;
                     }
-#line 8057 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8239 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 372:
-#line 2890 "mrbgems/mruby-compiler/core/parse.y"
+  case 380:
+#line 2974 "mrbgems/mruby-compiler/core/parse.y"
                    {
                       p->cmd_start = TRUE;
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 8066 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8248 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 373:
-#line 2896 "mrbgems/mruby-compiler/core/parse.y"
+  case 381:
+#line 2980 "mrbgems/mruby-compiler/core/parse.y"
                       {local_add_blk(p, 0);}
-#line 8072 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8254 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 374:
-#line 2897 "mrbgems/mruby-compiler/core/parse.y"
+  case 382:
+#line 2981 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = 0;
                     }
-#line 8080 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8262 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 375:
-#line 2901 "mrbgems/mruby-compiler/core/parse.y"
+  case 383:
+#line 2985 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_blk(p, 0);
                       (yyval.nd) = 0;
                     }
-#line 8089 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8271 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 376:
-#line 2906 "mrbgems/mruby-compiler/core/parse.y"
+  case 384:
+#line 2990 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-2].nd);
                     }
-#line 8097 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8279 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 377:
-#line 2913 "mrbgems/mruby-compiler/core/parse.y"
+  case 385:
+#line 2997 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = 0;
                     }
-#line 8105 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8287 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 378:
-#line 2917 "mrbgems/mruby-compiler/core/parse.y"
+  case 386:
+#line 3001 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = 0;
                     }
-#line 8113 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8295 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 381:
-#line 2927 "mrbgems/mruby-compiler/core/parse.y"
+  case 389:
+#line 3011 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_f(p, (yyvsp[0].id));
                       new_bv(p, (yyvsp[0].id));
                     }
-#line 8122 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8304 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 383:
-#line 2935 "mrbgems/mruby-compiler/core/parse.y"
+  case 391:
+#line 3019 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-2].nd);
                     }
-#line 8130 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8312 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 384:
-#line 2939 "mrbgems/mruby-compiler/core/parse.y"
+  case 392:
+#line 3023 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 8138 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8320 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 385:
-#line 2945 "mrbgems/mruby-compiler/core/parse.y"
+  case 393:
+#line 3029 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 8146 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8328 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 386:
-#line 2949 "mrbgems/mruby-compiler/core/parse.y"
+  case 394:
+#line 3033 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 8154 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8336 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 387:
-#line 2955 "mrbgems/mruby-compiler/core/parse.y"
+  case 395:
+#line 3039 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_nest(p);
                       nvars_nest(p);
                     }
-#line 8163 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8345 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 388:
-#line 2962 "mrbgems/mruby-compiler/core/parse.y"
+  case 396:
+#line 3046 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
                       local_unnest(p);
                       nvars_unnest(p);
                     }
-#line 8173 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8355 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 389:
-#line 2970 "mrbgems/mruby-compiler/core/parse.y"
+  case 397:
+#line 3054 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if ((yyvsp[-1].nd)->car == (node*)NODE_YIELD) {
                         yyerror(p, "block given to yield");
@@ -8183,159 +8365,159 @@ yyreduce:
                       }
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 8187 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8369 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 390:
-#line 2980 "mrbgems/mruby-compiler/core/parse.y"
+  case 398:
+#line 3064 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
                     }
-#line 8195 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8377 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 391:
-#line 2984 "mrbgems/mruby-compiler/core/parse.y"
+  case 399:
+#line 3068 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
                       call_with_block(p, (yyval.nd), (yyvsp[0].nd));
                     }
-#line 8204 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8386 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 392:
-#line 2989 "mrbgems/mruby-compiler/core/parse.y"
+  case 400:
+#line 3073 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-4].nd), (yyvsp[-2].id), (yyvsp[-1].nd), (yyvsp[-3].num));
                       call_with_block(p, (yyval.nd), (yyvsp[0].nd));
                     }
-#line 8213 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8395 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 393:
-#line 2996 "mrbgems/mruby-compiler/core/parse.y"
+  case 401:
+#line 3080 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_fcall(p, (yyvsp[-1].id), (yyvsp[0].nd));
                     }
-#line 8221 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8403 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 394:
-#line 3000 "mrbgems/mruby-compiler/core/parse.y"
+  case 402:
+#line 3084 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), (yyvsp[-2].num));
                     }
-#line 8229 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8411 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 395:
-#line 3004 "mrbgems/mruby-compiler/core/parse.y"
+  case 403:
+#line 3088 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-3].nd), (yyvsp[-1].id), (yyvsp[0].nd), tCOLON2);
                     }
-#line 8237 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8419 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 396:
-#line 3008 "mrbgems/mruby-compiler/core/parse.y"
+  case 404:
+#line 3092 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_call(p, (yyvsp[-2].nd), (yyvsp[0].id), 0, tCOLON2);
                     }
-#line 8245 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8427 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 397:
-#line 3012 "mrbgems/mruby-compiler/core/parse.y"
+  case 405:
+#line 3096 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), intern_lit("call"), (yyvsp[0].nd), (yyvsp[-1].num));
+                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM(call), (yyvsp[0].nd), (yyvsp[-1].num));
                     }
-#line 8253 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8435 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 398:
-#line 3016 "mrbgems/mruby-compiler/core/parse.y"
+  case 406:
+#line 3100 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), intern_lit("call"), (yyvsp[0].nd), tCOLON2);
+                      (yyval.nd) = new_call(p, (yyvsp[-2].nd), MRB_SYM(call), (yyvsp[0].nd), tCOLON2);
                     }
-#line 8261 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8443 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 399:
-#line 3020 "mrbgems/mruby-compiler/core/parse.y"
+  case 407:
+#line 3104 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_super(p, (yyvsp[0].nd));
                     }
-#line 8269 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8451 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 400:
-#line 3024 "mrbgems/mruby-compiler/core/parse.y"
+  case 408:
+#line 3108 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_zsuper(p);
                     }
-#line 8277 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8459 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 401:
-#line 3028 "mrbgems/mruby-compiler/core/parse.y"
+  case 409:
+#line 3112 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), intern_lit("[]"), (yyvsp[-1].nd), '.');
+                      (yyval.nd) = new_call(p, (yyvsp[-3].nd), MRB_QSYM(aref), (yyvsp[-1].nd), '.');
                     }
-#line 8285 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8467 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 402:
-#line 3034 "mrbgems/mruby-compiler/core/parse.y"
+  case 410:
+#line 3118 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_nest(p);
                       nvars_nest(p);
                       (yyval.num) = p->lineno;
                     }
-#line 8295 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8477 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 403:
-#line 3041 "mrbgems/mruby-compiler/core/parse.y"
+  case 411:
+#line 3125 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-3].num));
                       local_unnest(p);
                       nvars_unnest(p);
                     }
-#line 8306 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8488 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 404:
-#line 3048 "mrbgems/mruby-compiler/core/parse.y"
+  case 412:
+#line 3132 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_nest(p);
                       nvars_nest(p);
                       (yyval.num) = p->lineno;
                     }
-#line 8316 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8498 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 405:
-#line 3055 "mrbgems/mruby-compiler/core/parse.y"
+  case 413:
+#line 3139 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_block(p,(yyvsp[-2].nd),(yyvsp[-1].nd));
                       SET_LINENO((yyval.nd), (yyvsp[-3].num));
                       local_unnest(p);
                       nvars_unnest(p);
                     }
-#line 8327 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8509 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 406:
-#line 3066 "mrbgems/mruby-compiler/core/parse.y"
+  case 414:
+#line 3150 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = cons(cons((yyvsp[-3].nd), (yyvsp[-1].nd)), (yyvsp[0].nd));
                     }
-#line 8335 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8517 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 407:
-#line 3072 "mrbgems/mruby-compiler/core/parse.y"
+  case 415:
+#line 3156 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if ((yyvsp[0].nd)) {
                         (yyval.nd) = cons(cons(0, (yyvsp[0].nd)), 0);
@@ -8344,383 +8526,383 @@ yyreduce:
                         (yyval.nd) = 0;
                       }
                     }
-#line 8348 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8530 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 409:
-#line 3086 "mrbgems/mruby-compiler/core/parse.y"
+  case 417:
+#line 3170 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1(list3((yyvsp[-4].nd), (yyvsp[-3].nd), (yyvsp[-1].nd)));
                       if ((yyvsp[0].nd)) (yyval.nd) = append((yyval.nd), (yyvsp[0].nd));
                     }
-#line 8357 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8539 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 411:
-#line 3094 "mrbgems/mruby-compiler/core/parse.y"
+  case 419:
+#line 3178 "mrbgems/mruby-compiler/core/parse.y"
                     {
                         (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 8365 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8547 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 414:
-#line 3102 "mrbgems/mruby-compiler/core/parse.y"
+  case 422:
+#line 3186 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 8373 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8555 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 416:
-#line 3109 "mrbgems/mruby-compiler/core/parse.y"
+  case 424:
+#line 3193 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 8381 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8563 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 423:
-#line 3123 "mrbgems/mruby-compiler/core/parse.y"
+  case 431:
+#line 3207 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = concat_string(p, (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 8389 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8571 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 426:
-#line 3131 "mrbgems/mruby-compiler/core/parse.y"
+  case 434:
+#line 3215 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 8397 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8579 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 427:
-#line 3135 "mrbgems/mruby-compiler/core/parse.y"
+  case 435:
+#line 3219 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_dstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
                     }
-#line 8405 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8587 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 429:
-#line 3142 "mrbgems/mruby-compiler/core/parse.y"
+  case 437:
+#line 3226 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = append((yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 8413 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8595 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 430:
-#line 3148 "mrbgems/mruby-compiler/core/parse.y"
+  case 438:
+#line 3232 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 8421 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8603 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 431:
-#line 3152 "mrbgems/mruby-compiler/core/parse.y"
+  case 439:
+#line 3236 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = p->lex_strterm;
                       p->lex_strterm = NULL;
                     }
-#line 8430 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8612 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 432:
-#line 3158 "mrbgems/mruby-compiler/core/parse.y"
+  case 440:
+#line 3242 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lex_strterm = (yyvsp[-2].nd);
                       (yyval.nd) = list2((yyvsp[-3].nd), (yyvsp[-1].nd));
                     }
-#line 8439 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8621 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 433:
-#line 3163 "mrbgems/mruby-compiler/core/parse.y"
+  case 441:
+#line 3247 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1(new_literal_delim(p));
                     }
-#line 8447 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8629 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 434:
-#line 3167 "mrbgems/mruby-compiler/core/parse.y"
+  case 442:
+#line 3251 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1(new_literal_delim(p));
                     }
-#line 8455 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8637 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 435:
-#line 3173 "mrbgems/mruby-compiler/core/parse.y"
+  case 443:
+#line 3257 "mrbgems/mruby-compiler/core/parse.y"
                     {
                         (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 8463 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8645 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 436:
-#line 3177 "mrbgems/mruby-compiler/core/parse.y"
+  case 444:
+#line 3261 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_dxstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
                     }
-#line 8471 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8653 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 437:
-#line 3183 "mrbgems/mruby-compiler/core/parse.y"
+  case 445:
+#line 3267 "mrbgems/mruby-compiler/core/parse.y"
                     {
                         (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 8479 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8661 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 438:
-#line 3187 "mrbgems/mruby-compiler/core/parse.y"
+  case 446:
+#line 3271 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_dregx(p, (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 8487 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8669 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 442:
-#line 3200 "mrbgems/mruby-compiler/core/parse.y"
+  case 450:
+#line 3284 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       parser_heredoc_info * inf = parsing_heredoc_inf(p);
                       inf->doc = push(inf->doc, new_str(p, "", 0));
                       heredoc_end(p);
                     }
-#line 8497 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8679 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 443:
-#line 3206 "mrbgems/mruby-compiler/core/parse.y"
+  case 451:
+#line 3290 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       heredoc_end(p);
                     }
-#line 8505 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8687 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 446:
-#line 3216 "mrbgems/mruby-compiler/core/parse.y"
+  case 454:
+#line 3300 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       parser_heredoc_info * inf = parsing_heredoc_inf(p);
                       inf->doc = push(inf->doc, (yyvsp[0].nd));
                       heredoc_treat_nextline(p);
                     }
-#line 8515 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8697 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 447:
-#line 3222 "mrbgems/mruby-compiler/core/parse.y"
+  case 455:
+#line 3306 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = p->lex_strterm;
                       p->lex_strterm = NULL;
                     }
-#line 8524 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8706 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 448:
-#line 3228 "mrbgems/mruby-compiler/core/parse.y"
+  case 456:
+#line 3312 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       parser_heredoc_info * inf = parsing_heredoc_inf(p);
                       p->lex_strterm = (yyvsp[-2].nd);
                       inf->doc = push(push(inf->doc, (yyvsp[-3].nd)), (yyvsp[-1].nd));
                     }
-#line 8534 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8716 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 449:
-#line 3236 "mrbgems/mruby-compiler/core/parse.y"
+  case 457:
+#line 3320 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_words(p, list1((yyvsp[0].nd)));
                     }
-#line 8542 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8724 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 450:
-#line 3240 "mrbgems/mruby-compiler/core/parse.y"
+  case 458:
+#line 3324 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_words(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
                     }
-#line 8550 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8732 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 451:
-#line 3247 "mrbgems/mruby-compiler/core/parse.y"
+  case 459:
+#line 3331 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lstate = EXPR_ENDARG;
                       (yyval.nd) = new_sym(p, (yyvsp[0].id));
                     }
-#line 8559 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8741 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 452:
-#line 3252 "mrbgems/mruby-compiler/core/parse.y"
+  case 460:
+#line 3336 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lstate = EXPR_ENDARG;
                       (yyval.nd) = new_dsym(p, new_dstr(p, push((yyvsp[-1].nd), (yyvsp[0].nd))));
                     }
-#line 8568 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8750 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 453:
-#line 3259 "mrbgems/mruby-compiler/core/parse.y"
+  case 461:
+#line 3343 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.id) = (yyvsp[0].id);
                     }
-#line 8576 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8758 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 458:
-#line 3269 "mrbgems/mruby-compiler/core/parse.y"
+  case 466:
+#line 3353 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.id) = new_strsym(p, (yyvsp[0].nd));
                     }
-#line 8584 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8766 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 459:
-#line 3273 "mrbgems/mruby-compiler/core/parse.y"
+  case 467:
+#line 3357 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.id) = new_strsym(p, (yyvsp[0].nd));
                     }
-#line 8592 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8774 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 460:
-#line 3279 "mrbgems/mruby-compiler/core/parse.y"
+  case 468:
+#line 3363 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_symbols(p, list1((yyvsp[0].nd)));
                     }
-#line 8600 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8782 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 461:
-#line 3283 "mrbgems/mruby-compiler/core/parse.y"
+  case 469:
+#line 3367 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_symbols(p, push((yyvsp[-1].nd), (yyvsp[0].nd)));
                     }
-#line 8608 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8790 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 464:
-#line 3291 "mrbgems/mruby-compiler/core/parse.y"
+  case 472:
+#line 3375 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = negate_lit(p, (yyvsp[0].nd));
                     }
-#line 8616 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8798 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 465:
-#line 3295 "mrbgems/mruby-compiler/core/parse.y"
+  case 473:
+#line 3379 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = negate_lit(p, (yyvsp[0].nd));
                     }
-#line 8624 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8806 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 466:
-#line 3301 "mrbgems/mruby-compiler/core/parse.y"
+  case 474:
+#line 3385 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_lvar(p, (yyvsp[0].id));
                     }
-#line 8632 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8814 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 467:
-#line 3305 "mrbgems/mruby-compiler/core/parse.y"
+  case 475:
+#line 3389 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_ivar(p, (yyvsp[0].id));
                     }
-#line 8640 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8822 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 468:
-#line 3309 "mrbgems/mruby-compiler/core/parse.y"
+  case 476:
+#line 3393 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_gvar(p, (yyvsp[0].id));
                     }
-#line 8648 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8830 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 469:
-#line 3313 "mrbgems/mruby-compiler/core/parse.y"
+  case 477:
+#line 3397 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_cvar(p, (yyvsp[0].id));
                     }
-#line 8656 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8838 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 470:
-#line 3317 "mrbgems/mruby-compiler/core/parse.y"
+  case 478:
+#line 3401 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_const(p, (yyvsp[0].id));
                     }
-#line 8664 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8846 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 471:
-#line 3323 "mrbgems/mruby-compiler/core/parse.y"
+  case 479:
+#line 3407 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       assignable(p, (yyvsp[0].nd));
                     }
-#line 8672 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8854 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 472:
-#line 3327 "mrbgems/mruby-compiler/core/parse.y"
+  case 480:
+#line 3411 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "can't assign to numbered parameter");
                     }
-#line 8680 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8862 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 473:
-#line 3333 "mrbgems/mruby-compiler/core/parse.y"
+  case 481:
+#line 3417 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = var_reference(p, (yyvsp[0].nd));
                     }
-#line 8688 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8870 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 474:
-#line 3337 "mrbgems/mruby-compiler/core/parse.y"
+  case 482:
+#line 3421 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_nil(p);
                     }
-#line 8696 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8878 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 475:
-#line 3341 "mrbgems/mruby-compiler/core/parse.y"
+  case 483:
+#line 3425 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_self(p);
                     }
-#line 8704 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8886 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 476:
-#line 3345 "mrbgems/mruby-compiler/core/parse.y"
+  case 484:
+#line 3429 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_true(p);
                     }
-#line 8712 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8894 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 477:
-#line 3349 "mrbgems/mruby-compiler/core/parse.y"
+  case 485:
+#line 3433 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_false(p);
                     }
-#line 8720 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8902 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 478:
-#line 3353 "mrbgems/mruby-compiler/core/parse.y"
+  case 486:
+#line 3437 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       const char *fn = mrb_sym_name_len(p->mrb, p->filename_sym, NULL);
                       if (!fn) {
@@ -8728,22 +8910,22 @@ yyreduce:
                       }
                       (yyval.nd) = new_str(p, fn, strlen(fn));
                     }
-#line 8732 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8914 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 479:
-#line 3361 "mrbgems/mruby-compiler/core/parse.y"
+  case 487:
+#line 3445 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       char buf[16];
 
                       dump_int(p->lineno, buf);
                       (yyval.nd) = new_int(p, buf, 10, 0);
                     }
-#line 8743 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8925 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 480:
-#line 3368 "mrbgems/mruby-compiler/core/parse.y"
+  case 488:
+#line 3452 "mrbgems/mruby-compiler/core/parse.y"
                     {
 #ifdef MRB_UTF8_STRING
                       const char *enc = "UTF-8";
@@ -8752,561 +8934,561 @@ yyreduce:
 #endif
                       (yyval.nd) = new_str(p, enc, strlen(enc));
                     }
-#line 8756 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8938 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 483:
-#line 3383 "mrbgems/mruby-compiler/core/parse.y"
+  case 491:
+#line 3467 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = 0;
                     }
-#line 8764 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8946 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 484:
-#line 3387 "mrbgems/mruby-compiler/core/parse.y"
+  case 492:
+#line 3471 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lstate = EXPR_BEG;
                       p->cmd_start = TRUE;
                     }
-#line 8773 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8955 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 485:
-#line 3392 "mrbgems/mruby-compiler/core/parse.y"
+  case 493:
+#line 3476 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 8781 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8963 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 486:
-#line 3403 "mrbgems/mruby-compiler/core/parse.y"
+  case 494:
+#line 3487 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                       p->lstate = EXPR_BEG;
                       p->cmd_start = TRUE;
                     }
-#line 8791 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8973 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 487:
-#line 3409 "mrbgems/mruby-compiler/core/parse.y"
+  case 495:
+#line 3493 "mrbgems/mruby-compiler/core/parse.y"
                     {
 #if 1
                       /* til real keyword args implemented */
-                      mrb_sym r = mrb_intern_lit(p->mrb, "*");
-                      mrb_sym b = mrb_intern_lit(p->mrb, "&");
+                      mrb_sym r = MRB_QSYM(mul);
+                      mrb_sym b = MRB_QSYM(and);
                       local_add_f(p, r);
                       (yyval.nd) = new_args(p, 0, 0, r, 0,
                                     new_args_tail(p, 0, 0, b));
 #else
-                      mrb_sym r = mrb_intern_lit(p->mrb, "*");
-                      mrb_sym k = mrb_intern_lit(p->mrb, "**");
-                      mrb_sym b = mrb_intern_lit(p->mrb, "&");
+                      mrb_sym r = MRB_QSYM(mul);
+                      mrb_sym k = MRB_QSYM(pow);
+                      mrb_sym b = MRB_QSYM(and);
                       local_add_f(p, r); local_add_f(p, k);
                       (yyval.nd) = new_args(p, 0, 0, r, 0,
                                     new_args_tail(p, 0, new_kw_rest_args(p, nsym(k)), b));
 #endif
                     }
-#line 8813 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 8995 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 488:
-#line 3427 "mrbgems/mruby-compiler/core/parse.y"
+  case 497:
+#line 3514 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 8821 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9003 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 489:
-#line 3433 "mrbgems/mruby-compiler/core/parse.y"
+  case 498:
+#line 3520 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_nest(p);
                     }
-#line 8829 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9011 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 490:
-#line 3439 "mrbgems/mruby-compiler/core/parse.y"
+  case 499:
+#line 3526 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
                       local_unnest(p);
                     }
-#line 8839 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9021 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 491:
-#line 3445 "mrbgems/mruby-compiler/core/parse.y"
+  case 500:
+#line 3532 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
                       local_unnest(p);
                     }
-#line 8848 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9030 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 492:
-#line 3452 "mrbgems/mruby-compiler/core/parse.y"
+  case 501:
+#line 3539 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_kw_arg(p, (yyvsp[-1].id), cons((yyvsp[0].nd), locals_node(p)));
                       local_unnest(p);
                     }
-#line 8857 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9039 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 493:
-#line 3457 "mrbgems/mruby-compiler/core/parse.y"
+  case 502:
+#line 3544 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_kw_arg(p, (yyvsp[0].id), 0);
                       local_unnest(p);
                     }
-#line 8866 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9048 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 494:
-#line 3464 "mrbgems/mruby-compiler/core/parse.y"
+  case 503:
+#line 3551 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 8874 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9056 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 495:
-#line 3468 "mrbgems/mruby-compiler/core/parse.y"
+  case 504:
+#line 3555 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 8882 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9064 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 496:
-#line 3474 "mrbgems/mruby-compiler/core/parse.y"
+  case 505:
+#line 3561 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 8890 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9072 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 497:
-#line 3478 "mrbgems/mruby-compiler/core/parse.y"
+  case 506:
+#line 3565 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 8898 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9080 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 500:
-#line 3488 "mrbgems/mruby-compiler/core/parse.y"
+  case 509:
+#line 3575 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_kw_rest_args(p, nsym((yyvsp[0].id)));
                     }
-#line 8906 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9088 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 501:
-#line 3492 "mrbgems/mruby-compiler/core/parse.y"
+  case 510:
+#line 3579 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_kw_rest_args(p, 0);
                     }
-#line 8914 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9096 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 502:
-#line 3498 "mrbgems/mruby-compiler/core/parse.y"
+  case 511:
+#line 3585 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, (yyvsp[-3].nd), (yyvsp[-1].nd), (yyvsp[0].id));
                     }
-#line 8922 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9104 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 503:
-#line 3502 "mrbgems/mruby-compiler/core/parse.y"
+  case 512:
+#line 3589 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, (yyvsp[-1].nd), 0, (yyvsp[0].id));
                     }
-#line 8930 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9112 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 504:
-#line 3506 "mrbgems/mruby-compiler/core/parse.y"
+  case 513:
+#line 3593 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, 0, (yyvsp[-1].nd), (yyvsp[0].id));
                     }
-#line 8938 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9120 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 505:
-#line 3510 "mrbgems/mruby-compiler/core/parse.y"
+  case 514:
+#line 3597 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, 0, 0, (yyvsp[0].id));
                     }
-#line 8946 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9128 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 506:
-#line 3516 "mrbgems/mruby-compiler/core/parse.y"
+  case 515:
+#line 3603 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                     }
-#line 8954 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9136 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 507:
-#line 3520 "mrbgems/mruby-compiler/core/parse.y"
+  case 516:
+#line 3607 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args_tail(p, 0, 0, 0);
                     }
-#line 8962 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9144 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 508:
-#line 3526 "mrbgems/mruby-compiler/core/parse.y"
+  case 517:
+#line 3613 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
                     }
-#line 8970 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9152 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 509:
-#line 3530 "mrbgems/mruby-compiler/core/parse.y"
+  case 518:
+#line 3617 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-7].nd), (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 8978 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9160 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 510:
-#line 3534 "mrbgems/mruby-compiler/core/parse.y"
+  case 519:
+#line 3621 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-3].nd), (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
                     }
-#line 8986 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9168 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 511:
-#line 3538 "mrbgems/mruby-compiler/core/parse.y"
+  case 520:
+#line 3625 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-5].nd), (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 8994 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9176 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 512:
-#line 3542 "mrbgems/mruby-compiler/core/parse.y"
+  case 521:
+#line 3629 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-3].nd), 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
                     }
-#line 9002 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9184 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 513:
-#line 3546 "mrbgems/mruby-compiler/core/parse.y"
+  case 522:
+#line 3633 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-5].nd), 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 9010 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9192 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 514:
-#line 3550 "mrbgems/mruby-compiler/core/parse.y"
+  case 523:
+#line 3637 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, (yyvsp[-1].nd), 0, 0, 0, (yyvsp[0].nd));
                     }
-#line 9018 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9200 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 515:
-#line 3554 "mrbgems/mruby-compiler/core/parse.y"
+  case 524:
+#line 3641 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), (yyvsp[-1].id), 0, (yyvsp[0].nd));
                     }
-#line 9026 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9208 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 516:
-#line 3558 "mrbgems/mruby-compiler/core/parse.y"
+  case 525:
+#line 3645 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, (yyvsp[-5].nd), (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 9034 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9216 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 517:
-#line 3562 "mrbgems/mruby-compiler/core/parse.y"
+  case 526:
+#line 3649 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, (yyvsp[-1].nd), 0, 0, (yyvsp[0].nd));
                     }
-#line 9042 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9224 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 518:
-#line 3566 "mrbgems/mruby-compiler/core/parse.y"
+  case 527:
+#line 3653 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, (yyvsp[-3].nd), 0, (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 9050 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9232 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 519:
-#line 3570 "mrbgems/mruby-compiler/core/parse.y"
+  case 528:
+#line 3657 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, 0, (yyvsp[-1].id), 0, (yyvsp[0].nd));
                     }
-#line 9058 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9240 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 520:
-#line 3574 "mrbgems/mruby-compiler/core/parse.y"
+  case 529:
+#line 3661 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, 0, (yyvsp[-3].id), (yyvsp[-1].nd), (yyvsp[0].nd));
                     }
-#line 9066 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9248 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 521:
-#line 3578 "mrbgems/mruby-compiler/core/parse.y"
+  case 530:
+#line 3665 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_args(p, 0, 0, 0, 0, (yyvsp[0].nd));
                     }
-#line 9074 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9256 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 522:
-#line 3582 "mrbgems/mruby-compiler/core/parse.y"
+  case 531:
+#line 3669 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      local_add_f(p, mrb_intern_lit(p->mrb, "&"));
+                      local_add_f(p, MRB_QSYM(and));
                       (yyval.nd) = new_args(p, 0, 0, 0, 0, 0);
                     }
-#line 9083 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9265 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 523:
-#line 3589 "mrbgems/mruby-compiler/core/parse.y"
+  case 532:
+#line 3676 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "formal argument cannot be a constant");
                       (yyval.nd) = 0;
                     }
-#line 9092 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9274 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 524:
-#line 3594 "mrbgems/mruby-compiler/core/parse.y"
+  case 533:
+#line 3681 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "formal argument cannot be an instance variable");
                       (yyval.nd) = 0;
                     }
-#line 9101 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9283 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 525:
-#line 3599 "mrbgems/mruby-compiler/core/parse.y"
+  case 534:
+#line 3686 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "formal argument cannot be a global variable");
                       (yyval.nd) = 0;
                     }
-#line 9110 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9292 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 526:
-#line 3604 "mrbgems/mruby-compiler/core/parse.y"
+  case 535:
+#line 3691 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "formal argument cannot be a class variable");
                       (yyval.nd) = 0;
                     }
-#line 9119 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9301 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 527:
-#line 3609 "mrbgems/mruby-compiler/core/parse.y"
+  case 536:
+#line 3696 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       yyerror(p, "formal argument cannot be a numbered parameter");
                       (yyval.nd) = 0;
                     }
-#line 9128 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9310 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 528:
-#line 3616 "mrbgems/mruby-compiler/core/parse.y"
+  case 537:
+#line 3703 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.id) = 0;
                     }
-#line 9136 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9318 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 529:
-#line 3620 "mrbgems/mruby-compiler/core/parse.y"
+  case 538:
+#line 3707 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_f(p, (yyvsp[0].id));
                       (yyval.id) = (yyvsp[0].id);
                     }
-#line 9145 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9327 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 530:
-#line 3627 "mrbgems/mruby-compiler/core/parse.y"
+  case 539:
+#line 3714 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_arg(p, (yyvsp[0].id));
                     }
-#line 9153 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9335 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 531:
-#line 3631 "mrbgems/mruby-compiler/core/parse.y"
+  case 540:
+#line 3718 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = local_switch(p);
                     }
-#line 9161 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9343 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 532:
-#line 3635 "mrbgems/mruby-compiler/core/parse.y"
+  case 541:
+#line 3722 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = new_masgn_param(p, (yyvsp[-1].nd), p->locals->car);
                       local_resume(p, (yyvsp[-2].nd));
                       local_add_f(p, 0);
                     }
-#line 9171 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9353 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 533:
-#line 3643 "mrbgems/mruby-compiler/core/parse.y"
+  case 542:
+#line 3730 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 9179 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9361 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 534:
-#line 3647 "mrbgems/mruby-compiler/core/parse.y"
+  case 543:
+#line 3734 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 9187 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9369 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 535:
-#line 3653 "mrbgems/mruby-compiler/core/parse.y"
+  case 544:
+#line 3740 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_f(p, (yyvsp[-1].id));
                       local_nest(p);
                       (yyval.id) = (yyvsp[-1].id);
                     }
-#line 9197 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9379 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 536:
-#line 3661 "mrbgems/mruby-compiler/core/parse.y"
+  case 545:
+#line 3748 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p)));
                       local_unnest(p);
                     }
-#line 9207 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9389 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 537:
-#line 3669 "mrbgems/mruby-compiler/core/parse.y"
+  case 546:
+#line 3756 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = cons(nsym((yyvsp[-1].id)), cons((yyvsp[0].nd), locals_node(p)));
                       local_unnest(p);
                     }
-#line 9217 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9399 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 538:
-#line 3677 "mrbgems/mruby-compiler/core/parse.y"
+  case 547:
+#line 3764 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 9225 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9407 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 539:
-#line 3681 "mrbgems/mruby-compiler/core/parse.y"
+  case 548:
+#line 3768 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 9233 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9415 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 540:
-#line 3687 "mrbgems/mruby-compiler/core/parse.y"
+  case 549:
+#line 3774 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                     }
-#line 9241 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9423 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 541:
-#line 3691 "mrbgems/mruby-compiler/core/parse.y"
+  case 550:
+#line 3778 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 9249 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9431 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 544:
-#line 3701 "mrbgems/mruby-compiler/core/parse.y"
+  case 553:
+#line 3788 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       local_add_f(p, (yyvsp[0].id));
                       (yyval.id) = (yyvsp[0].id);
                     }
-#line 9258 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9440 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 545:
-#line 3706 "mrbgems/mruby-compiler/core/parse.y"
+  case 554:
+#line 3793 "mrbgems/mruby-compiler/core/parse.y"
                     {
-                      local_add_f(p, mrb_intern_lit(p->mrb, "*"));
+                      local_add_f(p, MRB_QSYM(mul));
                       (yyval.id) = -1;
                     }
-#line 9267 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9449 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 548:
-#line 3717 "mrbgems/mruby-compiler/core/parse.y"
+  case 557:
+#line 3804 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.id) = (yyvsp[0].id);
                     }
-#line 9275 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9457 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 549:
-#line 3723 "mrbgems/mruby-compiler/core/parse.y"
+  case 558:
+#line 3810 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.id) = (yyvsp[0].id);
                     }
-#line 9283 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9465 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 550:
-#line 3727 "mrbgems/mruby-compiler/core/parse.y"
+  case 559:
+#line 3814 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.id) = 0;
                     }
-#line 9291 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9473 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 551:
-#line 3733 "mrbgems/mruby-compiler/core/parse.y"
+  case 560:
+#line 3820 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[0].nd);
                       if (!(yyval.nd)) (yyval.nd) = new_nil(p);
                     }
-#line 9300 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9482 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 552:
-#line 3737 "mrbgems/mruby-compiler/core/parse.y"
+  case 561:
+#line 3824 "mrbgems/mruby-compiler/core/parse.y"
                       {p->lstate = EXPR_BEG;}
-#line 9306 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9488 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 553:
-#line 3738 "mrbgems/mruby-compiler/core/parse.y"
+  case 562:
+#line 3825 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       if ((yyvsp[-1].nd) == 0) {
                         yyerror(p, "can't define singleton method for ().");
@@ -9329,55 +9511,55 @@ yyreduce:
                       }
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 9333 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9515 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 555:
-#line 3764 "mrbgems/mruby-compiler/core/parse.y"
+  case 564:
+#line 3851 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = (yyvsp[-1].nd);
                     }
-#line 9341 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9523 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 556:
-#line 3770 "mrbgems/mruby-compiler/core/parse.y"
+  case 565:
+#line 3857 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = list1((yyvsp[0].nd));
                       NODE_LINENO((yyval.nd), (yyvsp[0].nd));
                     }
-#line 9350 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9532 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 557:
-#line 3775 "mrbgems/mruby-compiler/core/parse.y"
+  case 566:
+#line 3862 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = push((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 9358 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9540 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 560:
-#line 3785 "mrbgems/mruby-compiler/core/parse.y"
+  case 569:
+#line 3872 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[-2].nd));
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = cons((yyvsp[-2].nd), (yyvsp[0].nd));
                     }
-#line 9368 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9550 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 561:
-#line 3791 "mrbgems/mruby-compiler/core/parse.y"
+  case 570:
+#line 3878 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = cons(new_sym(p, (yyvsp[-2].id)), (yyvsp[0].nd));
                     }
-#line 9377 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9559 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 562:
-#line 3796 "mrbgems/mruby-compiler/core/parse.y"
+  case 571:
+#line 3883 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       if ((yyvsp[-2].nd)->car == (node*)NODE_DSTR) {
@@ -9387,67 +9569,67 @@ yyreduce:
                         (yyval.nd) = cons(new_sym(p, new_strsym(p, (yyvsp[-2].nd))), (yyvsp[0].nd));
                       }
                     }
-#line 9391 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9573 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 563:
-#line 3806 "mrbgems/mruby-compiler/core/parse.y"
+  case 572:
+#line 3893 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       void_expr_error(p, (yyvsp[0].nd));
                       (yyval.nd) = cons(new_kw_rest_args(p, 0), (yyvsp[0].nd));
                     }
-#line 9400 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9582 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 576:
-#line 3833 "mrbgems/mruby-compiler/core/parse.y"
+  case 585:
+#line 3920 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.num) = '.';
                     }
-#line 9408 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9590 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 577:
-#line 3837 "mrbgems/mruby-compiler/core/parse.y"
+  case 586:
+#line 3924 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.num) = 0;
                     }
-#line 9416 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9598 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 579:
-#line 3844 "mrbgems/mruby-compiler/core/parse.y"
+  case 588:
+#line 3931 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.num) = tCOLON2;
                     }
-#line 9424 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9606 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 588:
-#line 3865 "mrbgems/mruby-compiler/core/parse.y"
+  case 597:
+#line 3952 "mrbgems/mruby-compiler/core/parse.y"
                       {yyerrok;}
-#line 9430 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9612 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 591:
-#line 3871 "mrbgems/mruby-compiler/core/parse.y"
+  case 600:
+#line 3958 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       p->lineno += (yyvsp[0].num);
                       p->column = 0;
                     }
-#line 9439 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9621 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
-  case 594:
-#line 3882 "mrbgems/mruby-compiler/core/parse.y"
+  case 603:
+#line 3969 "mrbgems/mruby-compiler/core/parse.y"
                     {
                       (yyval.nd) = 0;
                     }
-#line 9447 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9629 "mrbgems/mruby-compiler/core/y.tab.c"
     break;
 
 
-#line 9451 "mrbgems/mruby-compiler/core/y.tab.c"
+#line 9633 "mrbgems/mruby-compiler/core/y.tab.c"
 
       default: break;
     }
@@ -9679,7 +9861,7 @@ yyreturn:
 #endif
   return yyresult;
 }
-#line 3886 "mrbgems/mruby-compiler/core/parse.y"
+#line 3973 "mrbgems/mruby-compiler/core/parse.y"
 
 #define pylval  (*((YYSTYPE*)(p->ylval)))
 
@@ -10758,7 +10940,7 @@ parser_yylex(parser_state *p)
   case '*':
     if ((c = nextc(p)) == '*') {
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit("**");
+        pylval.id = MRB_QSYM(pow);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -10776,7 +10958,7 @@ parser_yylex(parser_state *p)
     }
     else {
       if (c == '=') {
-        pylval.id = intern_lit("*");
+        pylval.id = MRB_QSYM(mul);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -10892,7 +11074,7 @@ parser_yylex(parser_state *p)
     }
     if (c == '<') {
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit("<<");
+        pylval.id = MRB_QSYM(lshift);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -10914,7 +11096,7 @@ parser_yylex(parser_state *p)
     }
     if (c == '>') {
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit(">>");
+        pylval.id = MRB_QSYM(rshift);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -11022,7 +11204,7 @@ parser_yylex(parser_state *p)
     if ((c = nextc(p)) == '&') {
       p->lstate = EXPR_BEG;
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit("&&");
+        pylval.id = MRB_QSYM(andand);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -11034,7 +11216,7 @@ parser_yylex(parser_state *p)
       return tANDDOT;
     }
     else if (c == '=') {
-      pylval.id = intern_lit("&");
+      pylval.id = MRB_QSYM(and);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -11061,7 +11243,7 @@ parser_yylex(parser_state *p)
     if ((c = nextc(p)) == '|') {
       p->lstate = EXPR_BEG;
       if ((c = nextc(p)) == '=') {
-        pylval.id = intern_lit("||");
+        pylval.id = MRB_QSYM(oror);
         p->lstate = EXPR_BEG;
         return tOP_ASGN;
       }
@@ -11069,7 +11251,7 @@ parser_yylex(parser_state *p)
       return tOROP;
     }
     if (c == '=') {
-      pylval.id = intern_lit("|");
+      pylval.id = MRB_QSYM(or);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -11093,7 +11275,7 @@ parser_yylex(parser_state *p)
       return '+';
     }
     if (c == '=') {
-      pylval.id = intern_lit("+");
+      pylval.id = MRB_QSYM(add);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -11121,7 +11303,7 @@ parser_yylex(parser_state *p)
       return '-';
     }
     if (c == '=') {
-      pylval.id = intern_lit("-");
+      pylval.id = MRB_QSYM(sub);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -11371,7 +11553,7 @@ parser_yylex(parser_state *p)
     }
     tokfix(p);
     if (is_float) {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
       yywarning_s(p, "floating point numbers are not supported", tok(p));
       pylval.nd = new_int(p, "0", 10, 0);
       return tINTEGER;
@@ -11441,7 +11623,7 @@ parser_yylex(parser_state *p)
       return tREGEXP_BEG;
     }
     if ((c = nextc(p)) == '=') {
-      pylval.id = intern_lit("/");
+      pylval.id = MRB_QSYM(div);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -11460,7 +11642,7 @@ parser_yylex(parser_state *p)
 
   case '^':
     if ((c = nextc(p)) == '=') {
-      pylval.id = intern_lit("^");
+      pylval.id = MRB_QSYM(xor);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -11637,7 +11819,7 @@ parser_yylex(parser_state *p)
       }
     }
     if ((c = nextc(p)) == '=') {
-      pylval.id = intern_lit("%");
+      pylval.id = MRB_QSYM(mod);
       p->lstate = EXPR_BEG;
       return tOP_ASGN;
     }
@@ -12265,7 +12447,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
   struct RClass *target = mrb->object_class;
   struct RProc *proc;
   mrb_value v;
-  unsigned int keep = 0;
+  mrb_int keep = 0;
 
   if (!p) {
     return mrb_undef_value();
@@ -12285,7 +12467,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
     }
     else {
       if (mrb->exc == NULL) {
-        mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
+        mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SYNTAX_ERROR, "syntax error"));
       }
       mrb_parser_free(p);
       return mrb_undef_value();
@@ -12295,7 +12477,7 @@ mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c)
   mrb_parser_free(p);
   if (proc == NULL) {
     if (mrb->exc == NULL) {
-      mrb->exc = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
+      mrb->exc = mrb_obj_ptr(mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "codegen error"));
     }
     return mrb_undef_value();
   }
diff --git a/mrbgems/mruby-complex/mrblib/complex.rb b/mrbgems/mruby-complex/mrblib/complex.rb
index 74c128a07..67f940865 100644
--- a/mrbgems/mruby-complex/mrblib/complex.rb
+++ b/mrbgems/mruby-complex/mrblib/complex.rb
@@ -104,7 +104,7 @@ class Complex < Numeric
 
   alias_method :imag, :imaginary
 
-  [Fixnum, Float].each do |cls|
+  [Integer, Float].each do |cls|
     [:+, :-, :*, :/, :==].each do |op|
       cls.instance_eval do
         original_operator_name = :"__original_operator_#{op}_complex"
diff --git a/mrbgems/mruby-complex/src/complex.c b/mrbgems/mruby-complex/src/complex.c
index 0432da633..6b7486ab0 100644
--- a/mrbgems/mruby-complex/src/complex.c
+++ b/mrbgems/mruby-complex/src/complex.c
@@ -3,8 +3,8 @@
 #include <mruby/numeric.h>
 #include <math.h>
 
-#ifdef MRB_WITHOUT_FLOAT
-# error Complex conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb'
+#ifdef MRB_NO_FLOAT
+# error Complex conflicts with 'MRB_NO_FLOAT' configuration
 #endif
 
 struct mrb_complex {
@@ -12,13 +12,13 @@ struct mrb_complex {
   mrb_float imaginary;
 };
 
-#ifdef MRB_USE_FLOAT
+#ifdef MRB_USE_FLOAT32
 #define F(x) x##f
 #else
 #define F(x) x
 #endif
 
-#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT)
+#if defined(MRB_64BIT) || defined(MRB_USE_FLOAT32)
 
 #define COMPLEX_USE_ISTRUCT
 /* use TT_ISTRUCT */
@@ -69,7 +69,7 @@ complex_ptr(mrb_state *mrb, mrb_value v)
 static mrb_value
 complex_new(mrb_state *mrb, mrb_float real, mrb_float imaginary)
 {
-  struct RClass *c = mrb_class_get(mrb, "Complex");
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Complex));
   struct mrb_complex *p;
   struct RBasic *comp = complex_alloc(mrb, c, &p);
   p->real = real;
@@ -122,7 +122,7 @@ complex_to_i(mrb_state *mrb, mrb_value self)
   if (p->imaginary != 0) {
     mrb_raisef(mrb, E_RANGE_ERROR, "can't convert %v into Float", self);
   }
-  return mrb_int_value(mrb, p->real);
+  return mrb_int_value(mrb, (mrb_int)p->real);
 }
 
 static mrb_value
@@ -224,7 +224,7 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb)
 #ifdef COMPLEX_USE_ISTRUCT
   mrb_assert(sizeof(struct mrb_complex) < ISTRUCT_DATA_SIZE);
 #endif
-  comp = mrb_define_class(mrb, "Complex", mrb_class_get(mrb, "Numeric"));
+  comp = mrb_define_class(mrb, "Complex", mrb_class_get_id(mrb, MRB_SYM(Numeric)));
 #ifdef COMPLEX_USE_ISTRUCT
   MRB_SET_INSTANCE_TT(comp, MRB_TT_ISTRUCT);
 #else
diff --git a/mrbgems/mruby-complex/test/complex.rb b/mrbgems/mruby-complex/test/complex.rb
index d996e8277..8f9634048 100644
--- a/mrbgems/mruby-complex/test/complex.rb
+++ b/mrbgems/mruby-complex/test/complex.rb
@@ -56,11 +56,11 @@ end
 assert 'Complex#/' do
   assert_complex Complex(2, 3)  / Complex(2, 3) , (1                  + 0i)
   assert_complex Complex(900)   / Complex(1)    , (900                + 0i)
-  assert_complex Complex(-2, 9) / Complex(-9, 2), ((36 / 85)          - (77i / 85))
-  assert_complex Complex(9, 8)  / 4             , ((9 / 4)            + 2i)
+  assert_complex Complex(-2, 9) / Complex(-9, 2), ((36.0 / 85)        - (77i / 85))
+  assert_complex Complex(9, 8)  / 4             , ((9.0 / 4)          + 2i)
   assert_complex Complex(20, 9) / 9.8           , (2.0408163265306123 + 0.9183673469387754i)
   if 1e39.infinite? then
-    # MRB_USE_FLOAT in effect
+    # MRB_USE_FLOAT32 in effect
     ten = 1e21
     one = 1e20
   else
@@ -80,7 +80,7 @@ assert 'Complex#abs' do
   assert_float Complex(-1).abs,        1
   assert_float Complex(3.0, -4.0).abs, 5.0
   if 1e39.infinite? then
-    # MRB_USE_FLOAT in effect
+    # MRB_USE_FLOAT32 in effect
     exp = 125
   else
     exp = 1021
diff --git a/mrbgems/mruby-enumerator/mrblib/enumerator.rb b/mrbgems/mruby-enumerator/mrblib/enumerator.rb
index 5a98dc964..f007b8553 100644
--- a/mrbgems/mruby-enumerator/mrblib/enumerator.rb
+++ b/mrbgems/mruby-enumerator/mrblib/enumerator.rb
@@ -130,6 +130,7 @@ class Enumerator
     @feedvalue = nil
     @stop_exc = false
   end
+
   attr_accessor :obj, :meth, :args
   attr_reader :fib
 
diff --git a/mrbgems/mruby-enumerator/test/enumerator.rb b/mrbgems/mruby-enumerator/test/enumerator.rb
index ecd6c4d65..26d5766fc 100644
--- a/mrbgems/mruby-enumerator/test/enumerator.rb
+++ b/mrbgems/mruby-enumerator/test/enumerator.rb
@@ -445,7 +445,7 @@ assert 'modifying existing methods' do
   }
 end
 
-assert 'Integral#times' do
+assert 'Integer#times' do
   a = 3
   b = a.times
   c = []
diff --git a/mrbgems/mruby-eval/src/eval.c b/mrbgems/mruby-eval/src/eval.c
index af6837b81..34a438060 100644
--- a/mrbgems/mruby-eval/src/eval.c
+++ b/mrbgems/mruby-eval/src/eval.c
@@ -20,7 +20,7 @@ create_proc_from_string(mrb_state *mrb, const char *s, mrb_int len, mrb_value bi
   struct REnv *e;
   mrb_callinfo *ci; /* callinfo of eval caller */
   struct RClass *target_class = NULL;
-  int bidx;
+  mrb_int bidx;
 
   if (!mrb_nil_p(binding)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "Binding of eval must be nil.");
@@ -179,7 +179,7 @@ void
 mrb_mruby_eval_gem_init(mrb_state* mrb)
 {
   mrb_define_module_function(mrb, mrb->kernel_module, "eval", f_eval, MRB_ARGS_ARG(1, 3));
-  mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
+  mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_eval", f_instance_eval, MRB_ARGS_OPT(3)|MRB_ARGS_BLOCK());
 }
 
 void
diff --git a/mrbgems/mruby-inline-struct/test/inline.c b/mrbgems/mruby-inline-struct/test/inline.c
index 5d307dcab..6764b1af4 100644
--- a/mrbgems/mruby-inline-struct/test/inline.c
+++ b/mrbgems/mruby-inline-struct/test/inline.c
@@ -10,10 +10,10 @@ istruct_test_initialize(mrb_state *mrb, mrb_value self)
   mrb_int size = mrb_istruct_size();
   mrb_value object = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(object)) {
+  if (mrb_integer_p(object)) {
     strncpy(string, "fixnum", size-1);
   }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   else if (mrb_float_p(object)) {
     strncpy(string, "float", size-1);
   }
diff --git a/mrbgems/mruby-io/mrblib/file.rb b/mrbgems/mruby-io/mrblib/file.rb
index aa73252e1..9398acef6 100644
--- a/mrbgems/mruby-io/mrblib/file.rb
+++ b/mrbgems/mruby-io/mrblib/file.rb
@@ -2,7 +2,7 @@ class File < IO
   attr_accessor :path
 
   def initialize(fd_or_path, mode = "r", perm = 0666)
-    if fd_or_path.kind_of? Fixnum
+    if fd_or_path.kind_of? Integer
       super(fd_or_path, mode)
     else
       @path = fd_or_path
diff --git a/mrbgems/mruby-io/mrblib/io.rb b/mrbgems/mruby-io/mrblib/io.rb
index e597db886..034f88529 100644
--- a/mrbgems/mruby-io/mrblib/io.rb
+++ b/mrbgems/mruby-io/mrblib/io.rb
@@ -186,7 +186,7 @@ class IO
 
   def read(length = nil, outbuf = "")
     unless length.nil?
-      unless length.is_a? Fixnum
+      unless length.is_a? Integer
         raise TypeError.new "can't convert #{length.class} into Integer"
       end
       if length < 0
@@ -229,7 +229,7 @@ class IO
     case arg
     when String
       rs = arg
-    when Fixnum
+    when Integer
       rs = "\n"
       limit = arg
     else
diff --git a/mrbgems/mruby-io/src/file.c b/mrbgems/mruby-io/src/file.c
index 53ed4b69d..d272cab7d 100644
--- a/mrbgems/mruby-io/src/file.c
+++ b/mrbgems/mruby-io/src/file.c
@@ -399,7 +399,7 @@ mrb_file_mtime(mrb_state *mrb, mrb_value self)
 
   if (mrb_fstat(fd, &st) == -1)
     return mrb_false_value();
-  return mrb_fixnum_value((mrb_int)st.st_mtime);
+  return mrb_int_value(mrb, (mrb_int)st.st_mtime);
 }
 
 static mrb_value
@@ -448,8 +448,8 @@ mrb_file_size(mrb_state *mrb, mrb_value self)
   }
 
   if (st.st_size > MRB_INT_MAX) {
-#ifdef MRB_WITHOUT_FLOAT
-    mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_WITHOUT_FLOAT");
+#ifdef MRB_NO_FLOAT
+    mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_NO_FLOAT");
 #else
     return mrb_float_value(mrb, (mrb_float)st.st_size);
 #endif
@@ -614,36 +614,36 @@ mrb_init_file(mrb_state *mrb)
   mrb_define_method(mrb, file, "size", mrb_file_size, MRB_ARGS_NONE());
   mrb_define_method(mrb, file, "truncate", mrb_file_truncate, MRB_ARGS_REQ(1));
 
-  cnst = mrb_define_module_under(mrb, file, "Constants");
-  mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));
-  mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX));
-  mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN));
-  mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB));
-  mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR));
-  mrb_define_const(mrb, cnst, "PATH_SEPARATOR", mrb_str_new_cstr(mrb, PATH_SEPARATOR));
+  cnst = mrb_define_module_under_id(mrb, file, MRB_SYM(Constants));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_SH), mrb_fixnum_value(LOCK_SH));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_EX), mrb_fixnum_value(LOCK_EX));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_UN), mrb_fixnum_value(LOCK_UN));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(LOCK_NB), mrb_fixnum_value(LOCK_NB));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(SEPARATOR), mrb_str_new_cstr(mrb, FILE_SEPARATOR));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(PATH_SEPARATOR), mrb_str_new_cstr(mrb, PATH_SEPARATOR));
 #if defined(_WIN32) || defined(_WIN64)
-  mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_str_new_cstr(mrb, FILE_ALT_SEPARATOR));
 #else
-  mrb_define_const(mrb, cnst, "ALT_SEPARATOR", mrb_nil_value());
+  mrb_define_const_id(mrb, cnst, MRB_SYM(ALT_SEPARATOR), mrb_nil_value());
 #endif
-  mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE));
-
-  mrb_define_const(mrb, cnst, "RDONLY", mrb_fixnum_value(MRB_O_RDONLY));
-  mrb_define_const(mrb, cnst, "WRONLY", mrb_fixnum_value(MRB_O_WRONLY));
-  mrb_define_const(mrb, cnst, "RDWR", mrb_fixnum_value(MRB_O_RDWR));
-  mrb_define_const(mrb, cnst, "APPEND", mrb_fixnum_value(MRB_O_APPEND));
-  mrb_define_const(mrb, cnst, "CREAT", mrb_fixnum_value(MRB_O_CREAT));
-  mrb_define_const(mrb, cnst, "EXCL", mrb_fixnum_value(MRB_O_EXCL));
-  mrb_define_const(mrb, cnst, "TRUNC", mrb_fixnum_value(MRB_O_TRUNC));
-  mrb_define_const(mrb, cnst, "NONBLOCK", mrb_fixnum_value(MRB_O_NONBLOCK));
-  mrb_define_const(mrb, cnst, "NOCTTY", mrb_fixnum_value(MRB_O_NOCTTY));
-  mrb_define_const(mrb, cnst, "BINARY", mrb_fixnum_value(MRB_O_BINARY));
-  mrb_define_const(mrb, cnst, "SHARE_DELETE", mrb_fixnum_value(MRB_O_SHARE_DELETE));
-  mrb_define_const(mrb, cnst, "SYNC", mrb_fixnum_value(MRB_O_SYNC));
-  mrb_define_const(mrb, cnst, "DSYNC", mrb_fixnum_value(MRB_O_DSYNC));
-  mrb_define_const(mrb, cnst, "RSYNC", mrb_fixnum_value(MRB_O_RSYNC));
-  mrb_define_const(mrb, cnst, "NOFOLLOW", mrb_fixnum_value(MRB_O_NOFOLLOW));
-  mrb_define_const(mrb, cnst, "NOATIME", mrb_fixnum_value(MRB_O_NOATIME));
-  mrb_define_const(mrb, cnst, "DIRECT", mrb_fixnum_value(MRB_O_DIRECT));
-  mrb_define_const(mrb, cnst, "TMPFILE", mrb_fixnum_value(MRB_O_TMPFILE));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NULL), mrb_str_new_cstr(mrb, NULL_FILE));
+
+  mrb_define_const_id(mrb, cnst, MRB_SYM(RDONLY), mrb_fixnum_value(MRB_O_RDONLY));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(WRONLY), mrb_fixnum_value(MRB_O_WRONLY));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(RDWR), mrb_fixnum_value(MRB_O_RDWR));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(APPEND), mrb_fixnum_value(MRB_O_APPEND));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(CREAT), mrb_fixnum_value(MRB_O_CREAT));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(EXCL), mrb_fixnum_value(MRB_O_EXCL));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(TRUNC), mrb_fixnum_value(MRB_O_TRUNC));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NONBLOCK), mrb_fixnum_value(MRB_O_NONBLOCK));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NOCTTY), mrb_fixnum_value(MRB_O_NOCTTY));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(BINARY), mrb_fixnum_value(MRB_O_BINARY));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(SHARE_DELETE), mrb_fixnum_value(MRB_O_SHARE_DELETE));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(SYNC), mrb_fixnum_value(MRB_O_SYNC));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(DSYNC), mrb_fixnum_value(MRB_O_DSYNC));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(RSYNC), mrb_fixnum_value(MRB_O_RSYNC));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NOFOLLOW), mrb_fixnum_value(MRB_O_NOFOLLOW));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(NOATIME), mrb_fixnum_value(MRB_O_NOATIME));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(DIRECT), mrb_fixnum_value(MRB_O_DIRECT));
+  mrb_define_const_id(mrb, cnst, MRB_SYM(TMPFILE), mrb_fixnum_value(MRB_O_TMPFILE));
 }
diff --git a/mrbgems/mruby-io/src/file_test.c b/mrbgems/mruby-io/src/file_test.c
index b7a28f4d3..f1762369a 100644
--- a/mrbgems/mruby-io/src/file_test.c
+++ b/mrbgems/mruby-io/src/file_test.c
@@ -66,11 +66,13 @@ mrb_stat(mrb_state *mrb, mrb_value obj, struct stat *st)
   return mrb_stat0(mrb, obj, st, 0);
 }
 
+#ifdef S_ISLNK
 static int
 mrb_lstat(mrb_state *mrb, mrb_value obj, struct stat *st)
 {
   return mrb_stat0(mrb, obj, st, 1);
 }
+#endif
 
 /*
  * Document-method: directory?
@@ -302,7 +304,7 @@ mrb_filetest_s_size(mrb_state *mrb, mrb_value klass)
   if (mrb_stat(mrb, obj, &st) < 0)
     mrb_sys_fail(mrb, "mrb_stat");
 
-  return mrb_fixnum_value(st.st_size);
+  return mrb_int_value(mrb, st.st_size);
 }
 
 /*
@@ -324,7 +326,7 @@ mrb_filetest_s_size_p(mrb_state *mrb, mrb_value klass)
   if (st.st_size == 0)
     return mrb_nil_value();
 
-  return mrb_fixnum_value(st.st_size);
+  return mrb_int_value(mrb, st.st_size);
 }
 
 void
diff --git a/mrbgems/mruby-io/src/io.c b/mrbgems/mruby-io/src/io.c
index 2c9cba84a..0fa0f34b1 100644
--- a/mrbgems/mruby-io/src/io.c
+++ b/mrbgems/mruby-io/src/io.c
@@ -102,14 +102,14 @@ io_set_process_status(mrb_state *mrb, pid_t pid, int status)
   mrb_value v;
 
   c_status = NULL;
-  if (mrb_class_defined(mrb, "Process")) {
-    c_process = mrb_module_get(mrb, "Process");
-    if (mrb_const_defined(mrb, mrb_obj_value(c_process), mrb_intern_cstr(mrb, "Status"))) {
-      c_status = mrb_class_get_under(mrb, c_process, "Status");
+  if (mrb_class_defined_id(mrb, MRB_SYM(Process))) {
+    c_process = mrb_module_get_id(mrb, MRB_SYM(Process));
+    if (mrb_const_defined(mrb, mrb_obj_value(c_process), MRB_SYM(Status))) {
+      c_status = mrb_class_get_under_id(mrb, c_process, MRB_SYM(Status));
     }
   }
   if (c_status != NULL) {
-    v = mrb_funcall(mrb, mrb_obj_value(c_status), "new", 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
+    v = mrb_funcall_id(mrb, mrb_obj_value(c_status), MRB_SYM(new), 2, mrb_fixnum_value(pid), mrb_fixnum_value(status));
   } else {
     v = mrb_fixnum_value(WEXITSTATUS(status));
   }
@@ -327,19 +327,16 @@ mrb_io_alloc(mrb_state *mrb)
 #endif
 
 static int
-option_to_fd(mrb_state *mrb, mrb_value hash, const char *key)
+option_to_fd(mrb_state *mrb, mrb_value v)
 {
-  mrb_value opt;
+  if (mrb_undef_p(v)) return -1;
+  if (mrb_nil_p(v)) return -1;
 
-  if (!mrb_hash_p(hash)) return -1;
-  opt = mrb_hash_fetch(mrb, hash, mrb_symbol_value(mrb_intern_static(mrb, key, strlen(key))), mrb_nil_value());
-  if (mrb_nil_p(opt)) return -1;
-
-  switch (mrb_type(opt)) {
+  switch (mrb_type(v)) {
     case MRB_TT_DATA: /* IO */
-      return mrb_io_fileno(mrb, opt);
-    case MRB_TT_FIXNUM:
-      return (int)mrb_fixnum(opt);
+      return mrb_io_fileno(mrb, v);
+    case MRB_TT_INTEGER:
+      return (int)mrb_integer(v);
     default:
       mrb_raise(mrb, E_ARGUMENT_ERROR, "wrong exec redirect action");
       break;
@@ -353,8 +350,14 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
 {
   mrb_value cmd, io;
   mrb_value mode = mrb_str_new_cstr(mrb, "r");
-  mrb_value opt  = mrb_hash_new(mrb);
-
+  mrb_value kv[3];
+  mrb_sym knames[3] = {MRB_SYM(in), MRB_SYM(out), MRB_SYM(err)};
+  const mrb_kwargs kw = {
+    3, 0,
+    knames,
+    kv,
+    NULL,
+  };
   struct mrb_io *fptr;
   const char *pname;
   int pid = 0, flags;
@@ -366,23 +369,22 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
   HANDLE ofd[2];
 
   int doexec;
-  int opt_in, opt_out, opt_err;
 
   ifd[0] = INVALID_HANDLE_VALUE;
   ifd[1] = INVALID_HANDLE_VALUE;
   ofd[0] = INVALID_HANDLE_VALUE;
   ofd[1] = INVALID_HANDLE_VALUE;
 
-  mrb_get_args(mrb, "S|oH", &cmd, &mode, &opt);
+  mrb_get_args(mrb, "S|o:", &cmd, &mode, &kw, &kv);
   io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
 
   pname = RSTRING_CSTR(mrb, cmd);
   flags = mrb_io_mode_to_flags(mrb, mode);
 
   doexec = (strcmp("-", pname) != 0);
-  opt_in = option_to_fd(mrb, opt, "in");
-  opt_out = option_to_fd(mrb, opt, "out");
-  opt_err = option_to_fd(mrb, opt, "err");
+  option_to_fd(mrb, kv[0]);
+  option_to_fd(mrb, kv[1]);
+  option_to_fd(mrb, kv[2]);
 
   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
   saAttr.bInheritHandle = TRUE;
@@ -458,8 +460,14 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
 {
   mrb_value cmd, io, result;
   mrb_value mode = mrb_str_new_cstr(mrb, "r");
-  mrb_value opt  = mrb_hash_new(mrb);
-
+  mrb_value kv[3];
+  mrb_sym knames[3] = {MRB_SYM(in), MRB_SYM(out), MRB_SYM(err)};
+  const mrb_kwargs kw = {
+    3, 0,
+    knames,
+    kv,
+    NULL,
+  };
   struct mrb_io *fptr;
   const char *pname;
   int pid, flags, fd, write_fd = -1;
@@ -469,16 +477,16 @@ mrb_io_s_popen(mrb_state *mrb, mrb_value klass)
   int saved_errno;
   int opt_in, opt_out, opt_err;
 
-  mrb_get_args(mrb, "S|oH", &cmd, &mode, &opt);
+  mrb_get_args(mrb, "S|o:", &cmd, &mode, &kw);
   io = mrb_obj_value(mrb_data_object_alloc(mrb, mrb_class_ptr(klass), NULL, &mrb_io_type));
 
   pname = RSTRING_CSTR(mrb, cmd);
   flags = mrb_io_mode_to_flags(mrb, mode);
 
   doexec = (strcmp("-", pname) != 0);
-  opt_in = option_to_fd(mrb, opt, "in");
-  opt_out = option_to_fd(mrb, opt, "out");
-  opt_err = option_to_fd(mrb, opt, "err");
+  opt_in = option_to_fd(mrb, kv[0]);
+  opt_out = option_to_fd(mrb, kv[1]);
+  opt_err = option_to_fd(mrb, kv[2]);
 
   if (OPEN_READABLE_P(flags)) {
     if (pipe(pr) == -1) {
@@ -973,10 +981,10 @@ mrb_io_sysseek(mrb_state *mrb, mrb_value io)
     mrb_sys_fail(mrb, "sysseek");
   }
   if (pos > MRB_INT_MAX) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     return mrb_float_value(mrb, (mrb_float)pos);
 #else
-    mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_WITHOUT_FLOAT");
+    mrb_raise(mrb, E_IO_ERROR, "sysseek reached too far for MRB_NO_FLOAT");
 #endif
   } else {
     return mrb_fixnum_value(pos);
@@ -1076,12 +1084,12 @@ time2timeval(mrb_state *mrb, mrb_value time)
   struct timeval t = { 0, 0 };
 
   switch (mrb_type(time)) {
-    case MRB_TT_FIXNUM:
-      t.tv_sec = (ftime_t)mrb_fixnum(time);
+    case MRB_TT_INTEGER:
+      t.tv_sec = (ftime_t)mrb_integer(time);
       t.tv_usec = 0;
       break;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     case MRB_TT_FLOAT:
       t.tv_sec = (ftime_t)mrb_float(time);
       t.tv_usec = (fsuseconds_t)((mrb_float(time) - t.tv_sec) * 1000000.0);
diff --git a/mrbgems/mruby-io/test/io.rb b/mrbgems/mruby-io/test/io.rb
index 2088a61e3..76ae13a58 100644
--- a/mrbgems/mruby-io/test/io.rb
+++ b/mrbgems/mruby-io/test/io.rb
@@ -7,7 +7,7 @@ $cr, $crlf, $cmd = MRubyIOTestUtil.win? ? [1, "\r\n", "cmd /c "] : [0, "\n", ""]
 def assert_io_open(meth)
   assert "assert_io_open" do
     fd = IO.sysopen($mrbtest_io_rfname)
-    assert_equal Fixnum, fd.class
+    assert_equal Integer, fd.class
     io1 = IO.__send__(meth, fd)
     begin
       assert_equal IO, io1.class
@@ -27,7 +27,6 @@ def assert_io_open(meth)
 
     assert_raise(RuntimeError) { IO.__send__(meth, 1023) } # For Windows
     assert_raise(RuntimeError) { IO.__send__(meth, 1 << 26) }
-    assert_raise(RuntimeError) { IO.__send__(meth, 1 << 32) } if (1 << 32).kind_of?(Integer)
   end
 end
 
@@ -433,7 +432,7 @@ assert('IO.popen') do
     $? = nil
     io = IO.popen("#{$cmd}echo mruby-io")
     assert_true io.close_on_exec?
-    assert_equal Fixnum, io.pid.class
+    assert_equal Integer, io.pid.class
 
     out = io.read
     assert_equal out.class, String
diff --git a/mrbgems/mruby-kernel-ext/src/kernel.c b/mrbgems/mruby-kernel-ext/src/kernel.c
index 1d183aecd..6e8679f47 100644
--- a/mrbgems/mruby-kernel-ext/src/kernel.c
+++ b/mrbgems/mruby-kernel-ext/src/kernel.c
@@ -57,7 +57,7 @@ mrb_f_caller(mrb_state *mrb, mrb_value self)
     return mrb_ary_new(mrb);
   }
 
-  return mrb_funcall(mrb, bt, "[]", 2, mrb_fixnum_value(lev), mrb_fixnum_value(n));
+  return mrb_funcall_id(mrb, bt, MRB_QSYM(aref), 2, mrb_fixnum_value(lev), mrb_fixnum_value(n));
 }
 
 /*
@@ -84,7 +84,7 @@ mrb_f_method(mrb_state *mrb, mrb_value self)
  *  call-seq:
  *     Integer(arg,base=0)    -> integer
  *
- *  Converts <i>arg</i> to a <code>Fixnum</code>.
+ *  Converts <i>arg</i> to a <code>Integer</code>.
  *  Numeric types are converted directly (with floating point numbers
  *  being truncated).    <i>base</i> (0, or between 2 and 36) is a base for
  *  integer string representation.  If <i>arg</i> is a <code>String</code>,
@@ -112,7 +112,7 @@ mrb_f_integer(mrb_state *mrb, mrb_value self)
   return mrb_convert_to_integer(mrb, arg, base);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /*
  *  call-seq:
  *     Float(arg)    -> float
@@ -151,7 +151,7 @@ mrb_f_string(mrb_state *mrb, mrb_value self)
   mrb_value arg = mrb_get_arg1(mrb);
   mrb_value tmp;
 
-  tmp = mrb_convert_type(mrb, arg, MRB_TT_STRING, "String", "to_s");
+  tmp = mrb_type_convert(mrb, arg, MRB_TT_STRING, MRB_SYM(to_s));
   return tmp;
 }
 
@@ -170,7 +170,7 @@ mrb_f_array(mrb_state *mrb, mrb_value self)
   mrb_value arg = mrb_get_arg1(mrb);
   mrb_value tmp;
 
-  tmp = mrb_check_convert_type(mrb, arg, MRB_TT_ARRAY, "Array", "to_a");
+  tmp = mrb_type_convert_check(mrb, arg, MRB_TT_ARRAY, MRB_SYM(to_a));
   if (mrb_nil_p(tmp)) {
     return mrb_ary_new_from_values(mrb, 1, &arg);
   }
@@ -212,7 +212,7 @@ mrb_mruby_kernel_ext_gem_init(mrb_state *mrb)
   mrb_define_module_function(mrb, krn, "caller", mrb_f_caller, MRB_ARGS_OPT(2));
   mrb_define_method(mrb, krn, "__method__", mrb_f_method, MRB_ARGS_NONE());
   mrb_define_module_function(mrb, krn, "Integer", mrb_f_integer, MRB_ARGS_ARG(1,1));
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_define_module_function(mrb, krn, "Float", mrb_f_float, MRB_ARGS_REQ(1));
 #endif
   mrb_define_module_function(mrb, krn, "String", mrb_f_string, MRB_ARGS_REQ(1));
diff --git a/mrbgems/mruby-math/src/math.c b/mrbgems/mruby-math/src/math.c
index 88b33771b..f2622109d 100644
--- a/mrbgems/mruby-math/src/math.c
+++ b/mrbgems/mruby-math/src/math.c
@@ -4,8 +4,8 @@
 ** See Copyright Notice in mruby.h
 */
 
-#ifdef MRB_WITHOUT_FLOAT
-# error Math conflicts 'MRB_WITHOUT_FLOAT' configuration in your 'build_config.rb'
+#ifdef MRB_NO_FLOAT
+# error Math conflicts with 'MRB_NO_FLOAT' configuration
 #endif
 
 #include <mruby.h>
@@ -16,8 +16,8 @@
 static void
 domain_error(mrb_state *mrb, const char *func)
 {
-  struct RClass *math = mrb_module_get(mrb, "Math");
-  struct RClass *domainerror = mrb_class_get_under(mrb, math, "DomainError");
+  struct RClass *math = mrb_module_get_id(mrb, MRB_SYM(Math));
+  struct RClass *domainerror = mrb_class_get_under_id(mrb, math, MRB_SYM(DomainError));
   mrb_raisef(mrb, domainerror, "Numerical argument is out of domain - %s", func);
 }
 
@@ -629,7 +629,7 @@ math_cbrt(mrb_state *mrb, mrb_value obj)
  *     Math.frexp(numeric)    -> [ fraction, exponent ]
  *
  *  Returns a two-element array containing the normalized fraction (a
- *  <code>Float</code>) and exponent (a <code>Fixnum</code>) of
+ *  <code>Float</code>) and exponent (a <code>Integer</code>) of
  *  <i>numeric</i>.
  *
  *     fraction, exponent = Math.frexp(1234)   #=> [0.6025390625, 11]
@@ -730,18 +730,18 @@ mrb_mruby_math_gem_init(mrb_state* mrb)
   struct RClass *mrb_math;
   mrb_math = mrb_define_module(mrb, "Math");
 
-  mrb_define_class_under(mrb, mrb_math, "DomainError", mrb->eStandardError_class);
+  mrb_define_class_under_id(mrb, mrb_math, MRB_SYM(DomainError), mrb->eStandardError_class);
 
 #ifdef M_PI
-  mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, M_PI));
+  mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, M_PI));
 #else
-  mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(mrb, atan(1.0)*4.0));
+  mrb_define_const_id(mrb, mrb_math, MRB_SYM(PI), mrb_float_value(mrb, atan(1.0)*4.0));
 #endif
 
 #ifdef M_E
-  mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, M_E));
+  mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, M_E));
 #else
-  mrb_define_const(mrb, mrb_math, "E", mrb_float_value(mrb, exp(1.0)));
+  mrb_define_const_id(mrb, mrb_math, MRB_SYM(E), mrb_float_value(mrb, exp(1.0)));
 #endif
 
   mrb_define_module_function(mrb, mrb_math, "sin", math_sin, MRB_ARGS_REQ(1));
diff --git a/mrbgems/mruby-math/test/math.rb b/mrbgems/mruby-math/test/math.rb
index d2790e289..959eef788 100644
--- a/mrbgems/mruby-math/test/math.rb
+++ b/mrbgems/mruby-math/test/math.rb
@@ -209,17 +209,18 @@ assert('Math.atan2') do
   assert_float(+Math::PI, Math.atan2(+0.0, -0.0))
   assert_float(-Math::PI, Math.atan2(-0.0, -0.0))
 
+  assert_float(0, Math.atan2(0, 1))
+  assert_float(Math::PI / 4, Math.atan2(1, 1))
+  assert_float(Math::PI / 2, Math.atan2(1, 0))
+
   inf = Float::INFINITY
+  skip "Math.atan2() return NaN" if Math.atan2(+inf, -inf).nan?
   expected = 3.0 * Math::PI / 4.0
   assert_float(+expected, Math.atan2(+inf, -inf))
   assert_float(-expected, Math.atan2(-inf, -inf))
   expected = Math::PI / 4.0
   assert_float(+expected, Math.atan2(+inf, +inf))
   assert_float(-expected, Math.atan2(-inf, +inf))
-
-  assert_float(0, Math.atan2(0, 1))
-  assert_float(Math::PI / 4, Math.atan2(1, 1))
-  assert_float(Math::PI / 2, Math.atan2(1, 0))
 end
 
 assert('Math.ldexp') do
diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c
index 6c0dc5ad3..b421226f9 100644
--- a/mrbgems/mruby-metaprog/src/metaprog.c
+++ b/mrbgems/mruby-metaprog/src/metaprog.c
@@ -132,8 +132,8 @@ mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_local_variables(mrb_state *mrb, mrb_value self)
 {
-  struct RProc *proc;
-  mrb_irep *irep;
+  const struct RProc *proc;
+  const mrb_irep *irep;
   mrb_value vars;
   size_t i;
 
@@ -148,8 +148,8 @@ mrb_local_variables(mrb_state *mrb, mrb_value self)
     irep = proc->body.irep;
     if (irep->lv) {
       for (i = 0; i + 1 < irep->nlocals; ++i) {
-        if (irep->lv[i].name) {
-          mrb_sym sym = irep->lv[i].name;
+        if (irep->lv[i]) {
+          mrb_sym sym = irep->lv[i];
           const char *name = mrb_sym_name(mrb, sym);
           switch (name[0]) {
           case '*': case '&':
@@ -168,29 +168,50 @@ mrb_local_variables(mrb_state *mrb, mrb_value self)
   return mrb_hash_keys(mrb, vars);
 }
 
-KHASH_DECLARE(st, mrb_sym, char, FALSE)
+KHASH_DECLARE(st, mrb_sym, char, FALSE);
+KHASH_DEFINE(st, mrb_sym, char, FALSE, kh_int_hash_func, kh_int_hash_equal);
 
-static void
-method_entry_loop(mrb_state *mrb, struct RClass *klass, khash_t(st) *set, khash_t(st) *undef)
+union mt_ptr {
+  struct RProc *proc;
+  mrb_func_t func;
+};
+
+struct mt_elem {
+  union mt_ptr ptr;
+  size_t func_p:1;
+  mrb_sym key:sizeof(mrb_sym)*8-1;
+};
+
+struct mt_set {
+  khash_t(st) *set;
+  khash_t(st) *undef;
+};
+
+static int
+method_entry_i(mrb_state *mrb, mrb_sym mid, struct mt_elem *e, void *p)
 {
-  khint_t i;
+  struct mt_set *s = (struct mt_set*)p;
 
-  khash_t(mt) *h = klass->mt;
-  if (!h || kh_size(h) == 0) return;
-  for (i=0;i<kh_end(h);i++) {
-    if (kh_exist(h, i)) {
-      mrb_method_t m = kh_value(h, i);
-      if (MRB_METHOD_UNDEF_P(m)) {
-        if (undef) {
-          kh_put(st, mrb, undef, kh_key(h, i));
-        }
-      }
-      else if (undef == NULL ||
-               kh_get(st, mrb, undef, kh_key(h, i)) == kh_end(undef)) {
-        kh_put(st, mrb, set, kh_key(h, i));
-      }
+  if (e->ptr.proc == 0) {
+    if (s->undef) {
+      kh_put(st, mrb, s->undef, mid);
     }
   }
+  else if (s->undef == NULL ||
+           kh_get(st, mrb, s->undef, mid) == kh_end(s->undef)) {
+    kh_put(st, mrb, s->set, mid);
+  }
+  return 0;
+}
+
+static void
+method_entry_loop(mrb_state *mrb, struct RClass *klass, khash_t(st) *set, khash_t(st) *undef)
+{
+  struct mt_set s;
+
+  s.set = set;
+  s.undef = undef;
+  mrb_mt_foreach(mrb, klass, method_entry_i, (void*)&s);
 }
 
 static mrb_value
@@ -608,28 +629,6 @@ mrb_mod_instance_methods(mrb_state *mrb, mrb_value mod)
   return mrb_class_instance_method_list(mrb, recur, c, 0);
 }
 
-static void
-remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
-{
-  struct RClass *c = mrb_class_ptr(mod);
-  khash_t(mt) *h;
-  khiter_t k;
-
-  MRB_CLASS_ORIGIN(c);
-  h = c->mt;
-
-  if (h) {
-    k = kh_get(mt, mrb, h, mid);
-    if (k != kh_end(h)) {
-      kh_del(mt, mrb, h, k);
-      mrb_funcall(mrb, mod, "method_removed", 1, mrb_symbol_value(mid));
-      return;
-    }
-  }
-
-  mrb_name_error(mrb, mid, "method '%n' not defined in %v", mid, mod);
-}
-
 /* 15.2.2.4.41 */
 /*
  *  call-seq:
@@ -644,11 +643,13 @@ mrb_mod_remove_method(mrb_state *mrb, mrb_value mod)
 {
   mrb_int argc;
   mrb_value *argv;
+  struct RClass *c = mrb_class_ptr(mod);
 
   mrb_get_args(mrb, "*", &argv, &argc);
   mrb_check_frozen(mrb, mrb_obj_ptr(mod));
   while (argc--) {
-    remove_method(mrb, mod, mrb_obj_to_sym(mrb, *argv));
+    mrb_remove_method(mrb, c, mrb_obj_to_sym(mrb, *argv));
+    mrb_funcall_id(mrb, mod, MRB_SYM(method_removed), 1, *argv);
     argv++;
   }
   return mod;
@@ -664,7 +665,7 @@ mrb_mod_s_constants(mrb_state *mrb, mrb_value mod)
 static mrb_value
 mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
 {
-  struct RProc *proc;
+  const struct RProc *proc;
   mrb_value ary;
   struct RClass *c = NULL;
 
@@ -684,6 +685,9 @@ mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
   return ary;
 }
 
+/* implementation of #send method */
+mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+
 void
 mrb_mruby_metaprog_gem_init(mrb_state* mrb)
 {
diff --git a/mrbgems/mruby-metaprog/test/metaprog.rb b/mrbgems/mruby-metaprog/test/metaprog.rb
index 82ba0a3a5..84f4e00a0 100644
--- a/mrbgems/mruby-metaprog/test/metaprog.rb
+++ b/mrbgems/mruby-metaprog/test/metaprog.rb
@@ -395,15 +395,15 @@ end
 
 assert('alias_method and remove_method') do
   begin
-    Fixnum.alias_method :to_s_, :to_s
-    Fixnum.remove_method :to_s
+    Integer.alias_method :to_s_, :to_s
+    Integer.remove_method :to_s
 
     assert_nothing_raised do
       # segfaults if mrb_cptr is used
       1.to_s
     end
   ensure
-    Fixnum.alias_method :to_s, :to_s_
-    Fixnum.remove_method :to_s_
+    Integer.alias_method :to_s, :to_s_
+    Integer.remove_method :to_s_
   end
 end
diff --git a/mrbgems/mruby-method/src/method.c b/mrbgems/mruby-method/src/method.c
index 111b031b9..c6de6a7bd 100644
--- a/mrbgems/mruby-method/src/method.c
+++ b/mrbgems/mruby-method/src/method.c
@@ -29,24 +29,24 @@ static mrb_value
 unbound_method_bind(mrb_state *mrb, mrb_value self)
 {
   struct RObject *me;
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
-  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+  mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
   mrb_value recv = mrb_get_arg1(mrb);
 
   bind_check(mrb, recv, owner);
-  me = method_object_alloc(mrb, mrb_class_get(mrb, "Method"));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), owner);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), recv);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), name);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), proc);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), klass);
+  me = method_object_alloc(mrb, mrb_class_get_id(mrb, MRB_SYM(Method)));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), owner);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), proc);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), klass);
 
   return mrb_obj_value(me);
 }
 
-#define IV_GET(value, name) mrb_iv_get(mrb, value, mrb_intern_lit(mrb, name))
+#define IV_GET(value, name) mrb_iv_get(mrb, value, name)
 static mrb_value
 method_eql(mrb_state *mrb, mrb_value self)
 {
@@ -61,22 +61,22 @@ method_eql(mrb_state *mrb, mrb_value self)
   if (mrb_class(mrb, self) != mrb_class(mrb, other))
     return mrb_false_value();
 
-  klass = mrb_class_ptr(IV_GET(self, "_klass"));
-  if (klass != mrb_class_ptr(IV_GET(other, "_klass")))
+  klass = mrb_class_ptr(IV_GET(self, MRB_SYM(_klass)));
+  if (klass != mrb_class_ptr(IV_GET(other, MRB_SYM(_klass))))
     return mrb_false_value();
 
-  owner = mrb_class_ptr(IV_GET(self, "_owner"));
-  if (owner != mrb_class_ptr(IV_GET(other, "_owner")))
+  owner = mrb_class_ptr(IV_GET(self, MRB_SYM(_owner)));
+  if (owner != mrb_class_ptr(IV_GET(other, MRB_SYM(_owner))))
     return mrb_false_value();
 
-  receiver = IV_GET(self, "_recv");
-  if (!mrb_obj_equal(mrb, receiver, IV_GET(other, "_recv")))
+  receiver = IV_GET(self, MRB_SYM(_recv));
+  if (!mrb_obj_equal(mrb, receiver, IV_GET(other, MRB_SYM(_recv))))
     return mrb_false_value();
 
-  orig_proc = IV_GET(self, "_proc");
-  other_proc = IV_GET(other, "_proc");
+  orig_proc = IV_GET(self, MRB_SYM(_proc));
+  other_proc = IV_GET(other, MRB_SYM(_proc));
   if (mrb_nil_p(orig_proc) && mrb_nil_p(other_proc)) {
-    if (mrb_symbol(IV_GET(self, "_name")) == mrb_symbol(IV_GET(other, "_name")))
+    if (mrb_symbol(IV_GET(self, MRB_SYM(_name))) == mrb_symbol(IV_GET(other, MRB_SYM(_name))))
       return mrb_true_value();
     else
       return mrb_false_value();
@@ -118,7 +118,7 @@ mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RCl
   if (mrb_nil_p(proc)) {
     mrb_value missing_argv = mrb_ary_new_from_values(mrb, argc, argv);
     mrb_ary_unshift(mrb, missing_argv, name);
-    ret = mrb_funcall_argv(mrb, recv, mrb_intern_lit(mrb, "method_missing"), argc + 1, RARRAY_PTR(missing_argv));
+    ret = mrb_funcall_argv(mrb, recv, MRB_SYM(method_missing), argc + 1, RARRAY_PTR(missing_argv));
   }
   else if (!mrb_nil_p(block)) {
     /*
@@ -137,10 +137,10 @@ mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RCl
 static mrb_value
 method_call(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
-  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
-  struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+  mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+  struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, MRB_SYM(_owner)));
   mrb_int argc;
   mrb_value *argv, block;
 
@@ -151,10 +151,10 @@ method_call(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_bcall(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
-  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+  mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
   mrb_int argc;
   mrb_value *argv, block;
 
@@ -167,17 +167,17 @@ static mrb_value
 method_unbind(mrb_state *mrb, mrb_value self)
 {
   struct RObject *ume;
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
-  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+  mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
 
   ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod"));
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_owner"), owner);
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_recv"), mrb_nil_value());
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_name"), name);
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_proc"), proc);
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_klass"), klass);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_owner), owner);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_recv), mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_name), name);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_proc), proc);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_klass), klass);
 
   return mrb_obj_value(ume);
 }
@@ -196,10 +196,10 @@ method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
 static mrb_value
 method_super_method(mrb_state *mrb, mrb_value self)
 {
-  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
-  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+  mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+  mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
   struct RClass *super, *rklass;
   struct RProc *proc;
   struct RObject *me;
@@ -225,11 +225,11 @@ method_super_method(mrb_state *mrb, mrb_value self)
     super = super->c;
 
   me = method_object_alloc(mrb, mrb_obj_class(mrb, self));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(super));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), recv);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), name);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), mrb_obj_value(proc));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), mrb_obj_value(rklass));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), mrb_obj_value(super));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), mrb_obj_value(proc));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), mrb_obj_value(rklass));
 
   return mrb_obj_value(me);
 }
@@ -237,7 +237,7 @@ method_super_method(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_arity(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
   mrb_int arity = mrb_nil_p(proc) ? -1 : mrb_proc_arity(mrb_proc_ptr(proc));
   return mrb_fixnum_value(arity);
 }
@@ -245,7 +245,7 @@ method_arity(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_source_location(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
   struct RProc *rproc;
   struct RClass *orig;
   mrb_value ret;
@@ -256,7 +256,7 @@ method_source_location(mrb_state *mrb, mrb_value self)
   rproc = mrb_proc_ptr(proc);
   orig = rproc->c;
   rproc->c = mrb->proc_class;
-  ret = mrb_funcall(mrb, proc, "source_location", 0);
+  ret = mrb_funcall_id(mrb, proc, MRB_SYM(source_location), 0);
   rproc->c = orig;
   return ret;
 }
@@ -264,13 +264,13 @@ method_source_location(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_parameters(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
   struct RProc *rproc;
   struct RClass *orig;
   mrb_value ret;
 
   if (mrb_nil_p(proc)) {
-    mrb_value rest = mrb_symbol_value(mrb_intern_lit(mrb, "rest"));
+    mrb_value rest = mrb_symbol_value(MRB_SYM(rest));
     mrb_value arest = mrb_ary_new_from_values(mrb, 1, &rest);
     return mrb_ary_new_from_values(mrb, 1, &arest);
   }
@@ -278,7 +278,7 @@ method_parameters(mrb_state *mrb, mrb_value self)
   rproc = mrb_proc_ptr(proc);
   orig = rproc->c;
   rproc->c = mrb->proc_class;
-  ret = mrb_funcall(mrb, proc, "parameters", 0);
+  ret = mrb_funcall_id(mrb, proc, MRB_SYM(parameters), 0);
   rproc->c = orig;
   return ret;
 }
@@ -286,9 +286,9 @@ method_parameters(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_to_s(mrb_state *mrb, mrb_value self)
 {
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
-  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+  mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
   mrb_value str = mrb_str_new_lit(mrb, "#<");
   struct RClass *rklass;
 
@@ -322,10 +322,10 @@ mrb_search_method_owner(mrb_state *mrb, struct RClass *c, mrb_value obj, mrb_sym
     if (unbound) {
       goto name_error;
     }
-    if (!mrb_respond_to(mrb, obj, mrb_intern_lit(mrb, "respond_to_missing?"))) {
+    if (!mrb_respond_to(mrb, obj, MRB_QSYM(respond_to_missing_p))) {
       goto name_error;
     }
-    ret = mrb_funcall(mrb, obj, "respond_to_missing?", 2, mrb_symbol_value(name), mrb_true_value());
+    ret = mrb_funcall_id(mrb, obj, MRB_QSYM(respond_to_missing_p), 2, mrb_symbol_value(name), mrb_true_value());
     if (!mrb_test(ret)) {
       goto name_error;
     }
@@ -354,11 +354,11 @@ mrb_kernel_method(mrb_state *mrb, mrb_value self)
   mrb_search_method_owner(mrb, mrb_class(mrb, self), self, name, &owner, &proc, FALSE);
 
   me = method_object_alloc(mrb, mrb_class_get(mrb, "Method"));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(owner));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), self);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), mrb_symbol_value(name));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), proc ? mrb_obj_value(proc) : mrb_nil_value());
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), mrb_obj_value(mrb_class(mrb, self)));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), mrb_obj_value(owner));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), self);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_name), mrb_symbol_value(name));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), proc ? mrb_obj_value(proc) : mrb_nil_value());
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), mrb_obj_value(mrb_class(mrb, self)));
 
   return mrb_obj_value(me);
 }
@@ -376,11 +376,11 @@ mrb_module_instance_method(mrb_state *mrb, mrb_value self)
   mrb_search_method_owner(mrb, mrb_class_ptr(self), self, name, &owner, &proc, TRUE);
 
   ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod"));
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(owner));
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_recv"), mrb_nil_value());
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_name"), mrb_symbol_value(name));
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_proc"), proc ? mrb_obj_value(proc) : mrb_nil_value());
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_klass"), self);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_owner), mrb_obj_value(owner));
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_recv), mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_name), mrb_symbol_value(name));
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_proc), proc ? mrb_obj_value(proc) : mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_klass), self);
 
   return mrb_obj_value(ume);
 }
@@ -388,19 +388,19 @@ mrb_module_instance_method(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_owner(mrb_state *mrb, mrb_value self)
 {
-  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
+  return mrb_iv_get(mrb, self, MRB_SYM(_owner));
 }
 
 static mrb_value
 method_receiver(mrb_state *mrb, mrb_value self)
 {
-  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
+  return mrb_iv_get(mrb, self, MRB_SYM(_recv));
 }
 
 static mrb_value
 method_name(mrb_state *mrb, mrb_value self)
 {
-  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+  return mrb_iv_get(mrb, self, MRB_SYM(_name));
 }
 
 void
diff --git a/mrbgems/mruby-method/test/method.rb b/mrbgems/mruby-method/test/method.rb
index 641979d71..123ae34be 100644
--- a/mrbgems/mruby-method/test/method.rb
+++ b/mrbgems/mruby-method/test/method.rb
@@ -77,7 +77,7 @@ end
 
 assert 'instance' do
   assert_kind_of Method, 1.method(:+)
-  assert_kind_of UnboundMethod, Fixnum.instance_method(:+)
+  assert_kind_of UnboundMethod, Integer.instance_method(:+)
 end
 
 assert 'Method#call' do
@@ -404,9 +404,9 @@ assert 'UnboundMethod#arity' do
 end
 
 assert 'UnboundMethod#==' do
-  assert_false(Fixnum.instance_method(:+) == Fixnum.instance_method(:-))
-  assert_true(Fixnum.instance_method(:+) == Fixnum.instance_method(:+))
-  assert_false(Fixnum.instance_method(:+) == Float.instance_method(:+))
+  assert_false(Integer.instance_method(:+) == Integer.instance_method(:-))
+  assert_true(Integer.instance_method(:+) == Integer.instance_method(:+))
+  assert_false(Integer.instance_method(:+) == Float.instance_method(:+))
   assert_true(UnboundMethod.instance_method(:==) == UnboundMethod.instance_method(:eql?))
 end
 
diff --git a/mrbgems/mruby-numeric-ext/src/numeric_ext.c b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
index f8aff54bc..e5ec90866 100644
--- a/mrbgems/mruby-numeric-ext/src/numeric_ext.c
+++ b/mrbgems/mruby-numeric-ext/src/numeric_ext.c
@@ -53,24 +53,24 @@ mrb_int_nobits(mrb_state *mrb, mrb_value self)
 void
 mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
 {
-  struct RClass *i = mrb_module_get(mrb, "Integral");
+  struct RClass *i = mrb_class_get(mrb, "Integer");
 
   mrb_define_method(mrb, i, "allbits?", mrb_int_allbits, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, i, "anybits?", mrb_int_anybits, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, i, "nobits?", mrb_int_nobits, MRB_ARGS_REQ(1));
 
-#ifndef MRB_WITHOUT_FLOAT
-  mrb_define_const(mrb, mrb->float_class, "RADIX",        mrb_fixnum_value(MRB_FLT_RADIX));
-  mrb_define_const(mrb, mrb->float_class, "MANT_DIG",     mrb_fixnum_value(MRB_FLT_MANT_DIG));
-  mrb_define_const(mrb, mrb->float_class, "EPSILON",      mrb_float_value(mrb, MRB_FLT_EPSILON));
-  mrb_define_const(mrb, mrb->float_class, "DIG",          mrb_fixnum_value(MRB_FLT_DIG));
-  mrb_define_const(mrb, mrb->float_class, "MIN_EXP",      mrb_fixnum_value(MRB_FLT_MIN_EXP));
-  mrb_define_const(mrb, mrb->float_class, "MIN",          mrb_float_value(mrb, MRB_FLT_MIN));
-  mrb_define_const(mrb, mrb->float_class, "MIN_10_EXP",   mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
-  mrb_define_const(mrb, mrb->float_class, "MAX_EXP",      mrb_fixnum_value(MRB_FLT_MAX_EXP));
-  mrb_define_const(mrb, mrb->float_class, "MAX",          mrb_float_value(mrb, MRB_FLT_MAX));
-  mrb_define_const(mrb, mrb->float_class, "MAX_10_EXP",   mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
-#endif /* MRB_WITHOUT_FLOAT */
+#ifndef MRB_NO_FLOAT
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(RADIX),        mrb_fixnum_value(MRB_FLT_RADIX));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MANT_DIG),     mrb_fixnum_value(MRB_FLT_MANT_DIG));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(EPSILON),      mrb_float_value(mrb, MRB_FLT_EPSILON));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(DIG),          mrb_fixnum_value(MRB_FLT_DIG));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_EXP),      mrb_fixnum_value(MRB_FLT_MIN_EXP));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN),          mrb_float_value(mrb, MRB_FLT_MIN));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MIN_10_EXP),   mrb_fixnum_value(MRB_FLT_MIN_10_EXP));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_EXP),      mrb_fixnum_value(MRB_FLT_MAX_EXP));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX),          mrb_float_value(mrb, MRB_FLT_MAX));
+  mrb_define_const_id(mrb, mrb->float_class, MRB_SYM(MAX_10_EXP),   mrb_fixnum_value(MRB_FLT_MAX_10_EXP));
+#endif /* MRB_NO_FLOAT */
 }
 
 void
diff --git a/mrbgems/mruby-object-ext/src/object.c b/mrbgems/mruby-object-ext/src/object.c
index 31bb689f6..2d99ce8c2 100644
--- a/mrbgems/mruby-object-ext/src/object.c
+++ b/mrbgems/mruby-object-ext/src/object.c
@@ -17,7 +17,7 @@ nil_to_a(mrb_state *mrb, mrb_value obj)
   return mrb_ary_new(mrb);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /*
  *  call-seq:
  *     nil.to_f    -> 0.0
@@ -115,7 +115,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb)
   struct RClass * n = mrb->nil_class;
 
   mrb_define_method(mrb, n, "to_a", nil_to_a,       MRB_ARGS_NONE());
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_define_method(mrb, n, "to_f", nil_to_f,       MRB_ARGS_NONE());
 #endif
   mrb_define_method(mrb, n, "to_h", nil_to_h,       MRB_ARGS_NONE());
@@ -123,7 +123,7 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb)
 
   mrb_define_method(mrb, mrb->kernel_module, "itself", mrb_f_itself, MRB_ARGS_NONE());
 
-  mrb_define_method(mrb, mrb_class_get(mrb, "BasicObject"), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
+  mrb_define_method(mrb, mrb_class_get_id(mrb, MRB_SYM(BasicObject)), "instance_exec", mrb_obj_instance_exec, MRB_ARGS_ANY() | MRB_ARGS_BLOCK());
 }
 
 void
diff --git a/mrbgems/mruby-objectspace/src/mruby_objectspace.c b/mrbgems/mruby-objectspace/src/mruby_objectspace.c
index bded3afa8..d8013c20f 100644
--- a/mrbgems/mruby-objectspace/src/mruby_objectspace.c
+++ b/mrbgems/mruby-objectspace/src/mruby_objectspace.c
@@ -71,8 +71,8 @@ os_count_objects(mrb_state *mrb, mrb_value self)
 
   mrb_objspace_each_objects(mrb, os_count_object_type, &obj_count);
 
-  mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "TOTAL")), mrb_fixnum_value(obj_count.total));
-  mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_lit(mrb, "FREE")), mrb_fixnum_value(obj_count.freed));
+  mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(TOTAL)), mrb_fixnum_value(obj_count.total));
+  mrb_hash_set(mrb, hash, mrb_symbol_value(MRB_SYM(FREE)), mrb_fixnum_value(obj_count.freed));
 
   for (i = MRB_TT_FALSE; i < MRB_TT_MAXDEFINE; i++) {
     mrb_value type;
@@ -81,7 +81,7 @@ os_count_objects(mrb_state *mrb, mrb_value self)
       COUNT_TYPE(T_FALSE);
       COUNT_TYPE(T_FREE);
       COUNT_TYPE(T_TRUE);
-      COUNT_TYPE(T_FIXNUM);
+      COUNT_TYPE(T_INTEGER);
       COUNT_TYPE(T_SYMBOL);
       COUNT_TYPE(T_UNDEF);
       COUNT_TYPE(T_FLOAT);
diff --git a/mrbgems/mruby-os-memsize/src/memsize.c b/mrbgems/mruby-os-memsize/src/memsize.c
index 191ab062d..359c2683c 100644
--- a/mrbgems/mruby-os-memsize/src/memsize.c
+++ b/mrbgems/mruby-os-memsize/src/memsize.c
@@ -108,17 +108,6 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj)
       if(!MRB_PROC_CFUNC_P(proc)) size += os_memsize_of_irep(mrb, proc->body.irep);
       break;
     }
-    case MRB_TT_DATA:
-      size += mrb_objspace_page_slot_size();
-      break;
-#ifndef MRB_WITHOUT_FLOAT
-    case MRB_TT_FLOAT:
-#ifdef MRB_WORD_BOXING
-      size += mrb_objspace_page_slot_size() +
-              sizeof(struct RFloat);
-#endif
-      break;
-#endif
     case MRB_TT_RANGE:
 #ifndef MRB_RANGE_EMBED
       size += mrb_objspace_page_slot_size() +
@@ -131,22 +120,25 @@ os_memsize_of_object(mrb_state* mrb, mrb_value obj)
       ptrdiff_t ci_size = f->cxt->ciend - f->cxt->cibase;
 
       size += mrb_objspace_page_slot_size() +
-        sizeof(struct RFiber) +
         sizeof(struct mrb_context) +
-        sizeof(struct RProc *) * f->cxt->esize +
-        sizeof(uint16_t *) * f->cxt->rsize +
         sizeof(mrb_value) * stack_size +
         sizeof(mrb_callinfo) * ci_size;
       break;
     }
-    case MRB_TT_ISTRUCT:
+#ifndef MRB_NO_FLOAT
+    case MRB_TT_FLOAT:
+#endif
+    case MRB_TT_INTEGER:
+      if (mrb_immediate_p(obj))
+        break;
+    case MRB_TT_DATA:
+  case MRB_TT_ISTRUCT:
       size += mrb_objspace_page_slot_size();
       break;
     /*  zero heap size types.
      *  immediate VM stack values, contained within mrb_state, or on C stack */
     case MRB_TT_TRUE:
     case MRB_TT_FALSE:
-    case MRB_TT_FIXNUM:
     case MRB_TT_BREAK:
     case MRB_TT_CPTR:
     case MRB_TT_SYMBOL:
diff --git a/mrbgems/mruby-pack/src/pack.c b/mrbgems/mruby-pack/src/pack.c
index e222cd946..9250e966d 100644
--- a/mrbgems/mruby-pack/src/pack.c
+++ b/mrbgems/mruby-pack/src/pack.c
@@ -9,10 +9,10 @@
 #include "mruby/numeric.h"
 #include "mruby/string.h"
 #include "mruby/variable.h"
+#include "mruby/endian.h"
 
 #include <ctype.h>
 #include <errno.h>
-#include <limits.h>
 #include <string.h>
 
 struct tmpl {
@@ -63,36 +63,6 @@ const static unsigned char base64chars[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 static unsigned char base64_dec_tab[128];
 
-#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER__)
-# define BYTE_ORDER __BYTE_ORDER__
-#endif
-#if !defined(BIG_ENDIAN) && defined(__ORDER_BIG_ENDIAN__)
-# define BIG_ENDIAN __ORDER_BIG_ENDIAN__
-#endif
-#if !defined(LITTLE_ENDIAN) && defined(__ORDER_LITTLE_ENDIAN__)
-# define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__
-#endif
-
-#ifdef BYTE_ORDER
-# if BYTE_ORDER == BIG_ENDIAN
-#  define littleendian 0
-#  define check_little_endian() (void)0
-# elif BYTE_ORDER == LITTLE_ENDIAN
-#  define littleendian 1
-#  define check_little_endian() (void)0
-# endif
-#endif
-#ifndef littleendian
-/* can't distinguish endian in compile time */
-static int littleendian = 0;
-static void
-check_little_endian(void)
-{
-  unsigned int n = 1;
-  littleendian = (*(unsigned char *)&n == 1);
-}
-#endif
-
 static unsigned int
 hex2int(unsigned char ch)
 {
@@ -143,7 +113,7 @@ static int
 pack_c(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
 {
   str = str_len_ensure(mrb, str, sidx + 1);
-  RSTRING_PTR(str)[sidx] = (char)mrb_fixnum(o);
+  RSTRING_PTR(str)[sidx] = (char)mrb_integer(o);
   return 1;
 }
 
@@ -163,7 +133,7 @@ pack_s(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint16_t n;
 
   str = str_len_ensure(mrb, str, sidx + 2);
-  n = (uint16_t)mrb_fixnum(o);
+  n = (uint16_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = n % 256;
     RSTRING_PTR(str)[sidx+1] = n / 256;
@@ -197,7 +167,7 @@ pack_l(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint32_t n;
 
   str = str_len_ensure(mrb, str, sidx + 4);
-  n = (uint32_t)mrb_fixnum(o);
+  n = (uint32_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff);
     RSTRING_PTR(str)[sidx+1] = (char)(n >> 8);
@@ -290,7 +260,7 @@ unpack_l(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un
 #ifndef MRB_INT64
     if (!FIXABLE(sl)) {
       i32tostr(msg, sizeof(msg), sl);
-      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg);
+      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
     }
 #endif
     n = sl;
@@ -298,7 +268,7 @@ unpack_l(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un
 #ifndef MRB_INT64
     if (!POSFIXABLE(ul)) {
       u32tostr(msg, sizeof(msg), ul);
-      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg);
+      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
     }
 #endif
     n = ul;
@@ -313,7 +283,7 @@ pack_q(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int fl
   uint64_t n;
 
   str = str_len_ensure(mrb, str, sidx + 8);
-  n = (uint64_t)mrb_fixnum(o);
+  n = (uint64_t)mrb_integer(o);
   if (flags & PACK_FLAG_LITTLEENDIAN) {
     RSTRING_PTR(str)[sidx+0] = (char)(n & 0xff);
     RSTRING_PTR(str)[sidx+1] = (char)(n >> 8);
@@ -411,13 +381,13 @@ unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un
     int64_t sll = ull;
     if (!FIXABLE(sll)) {
       i64tostr(msg, sizeof(msg), sll);
-      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg);
+      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
     }
     n = (mrb_int)sll;
   } else {
     if (!POSFIXABLE(ull)) {
       u64tostr(msg, sizeof(msg), ull);
-      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Fixnum: %s", msg);
+      mrb_raisef(mrb, E_RANGE_ERROR, "cannot unpack to Integer: %s", msg);
     }
     n = (mrb_int)ull;
   }
@@ -425,7 +395,7 @@ unpack_q(mrb_state *mrb, const unsigned char *src, int srclen, mrb_value ary, un
   return 8;
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static int
 pack_double(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, unsigned int flags)
 {
@@ -560,7 +530,7 @@ pack_utf8(mrb_state *mrb, mrb_value o, mrb_value str, mrb_int sidx, long count,
   int len = 0;
   uint32_t c = 0;
 
-  c = (uint32_t)mrb_fixnum(o);
+  c = (uint32_t)mrb_integer(o);
 
   /* Unicode character */
   /* from mruby-compiler gem */
@@ -1248,7 +1218,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary)
       if (type == PACK_TYPE_INTEGER) {
         o = mrb_to_int(mrb, o);
       }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       else if (type == PACK_TYPE_FLOAT) {
         if (!mrb_float_p(o)) {
           mrb_float f = mrb_to_flo(mrb, o);
@@ -1284,7 +1254,7 @@ mrb_pack_pack(mrb_state *mrb, mrb_value ary)
       case PACK_DIR_STR:
         ridx += pack_a(mrb, o, result, ridx, count, flags);
         break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       case PACK_DIR_DOUBLE:
         ridx += pack_double(mrb, o, result, ridx, flags);
         break;
@@ -1381,7 +1351,7 @@ pack_unpack(mrb_state *mrb, mrb_value str, int single)
       case PACK_DIR_QUAD:
         srcidx += unpack_q(mrb, sptr, srclen - srcidx, result, flags);
         break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       case PACK_DIR_FLOAT:
         srcidx += unpack_float(mrb, sptr, srclen - srcidx, result, flags);
         break;
@@ -1426,7 +1396,6 @@ mrb_pack_unpack1(mrb_state *mrb, mrb_value str)
 void
 mrb_mruby_pack_gem_init(mrb_state *mrb)
 {
-  check_little_endian();
   make_base64_dec_tab();
 
   mrb_define_method(mrb, mrb->array_class, "pack", mrb_pack_pack, MRB_ARGS_REQ(1));
diff --git a/mrbgems/mruby-print/src/print.c b/mrbgems/mruby-print/src/print.c
index df153d920..6e91e1941 100644
--- a/mrbgems/mruby-print/src/print.c
+++ b/mrbgems/mruby-print/src/print.c
@@ -17,22 +17,22 @@
 #endif
 
 static void
-printstr(mrb_state *mrb, const char *p, size_t len)
+printstr(mrb_state *mrb, const char *p, mrb_int len)
 {
 #if defined(_WIN32)
   if (isatty(fileno(stdout))) {
     DWORD written;
-    int wlen = MultiByteToWideChar(CP_UTF8, 0, p, len, NULL, 0);
+    int wlen = MultiByteToWideChar(CP_UTF8, 0, p, (int)len, NULL, 0);
     wchar_t* utf16 = (wchar_t*)mrb_malloc(mrb, (wlen+1) * sizeof(wchar_t));
-    if (MultiByteToWideChar(CP_UTF8, 0, p, len, utf16, wlen) > 0) {
+    if (MultiByteToWideChar(CP_UTF8, 0, p, (int)len, utf16, wlen) > 0) {
       utf16[wlen] = 0;
       WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE),
-                    utf16, wlen, &written, NULL);
+                    utf16, (DWORD)wlen, &written, NULL);
     }
     mrb_free(mrb, utf16);
   } else
 #endif
-    fwrite(p, len, 1, stdout);
+    fwrite(p, (size_t)len, 1, stdout);
   fflush(stdout);
 }
 
@@ -57,7 +57,7 @@ mrb_print(mrb_state *mrb, mrb_value self)
 
   mrb_get_args(mrb, "*", &argv, &argc);
   for (i=0; i<argc; i++) {
-    mrb_value s = mrb_str_to_str(mrb, argv[i]);
+    mrb_value s = mrb_obj_as_string(mrb, argv[i]);
     printstr(mrb, RSTRING_PTR(s), RSTRING_LEN(s));
   }
   return mrb_nil_value();
@@ -73,7 +73,7 @@ mrb_puts(mrb_state *mrb, mrb_value self)
 
   mrb_get_args(mrb, "*", &argv, &argc);
   for (i=0; i<argc; i++) {
-    mrb_value s = mrb_str_to_str(mrb, argv[i]);
+    mrb_value s = mrb_obj_as_string(mrb, argv[i]);
     mrb_int len = RSTRING_LEN(s);
     printstr(mrb, RSTRING_PTR(s), len);
     if (len == 0 || RSTRING_PTR(s)[len-1] != '\n') {
diff --git a/mrbgems/mruby-proc-ext/src/proc.c b/mrbgems/mruby-proc-ext/src/proc.c
index 5343c478f..2f4f77de7 100644
--- a/mrbgems/mruby-proc-ext/src/proc.c
+++ b/mrbgems/mruby-proc-ext/src/proc.c
@@ -21,7 +21,7 @@ mrb_proc_source_location(mrb_state *mrb, mrb_value self)
     return mrb_nil_value();
   }
   else {
-    mrb_irep *irep = p->body.irep;
+    const mrb_irep *irep = p->body.irep;
     int32_t line;
     const char *filename;
 
@@ -41,7 +41,7 @@ mrb_proc_inspect(mrb_state *mrb, mrb_value self)
   mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(self)));
 
   if (!MRB_PROC_CFUNC_P(p)) {
-    mrb_irep *irep = p->body.irep;
+    const mrb_irep *irep = p->body.irep;
     const char *filename;
     int32_t line;
     mrb_str_cat_lit(mrb, str, "@");
@@ -91,21 +91,24 @@ static mrb_value
 mrb_proc_parameters(mrb_state *mrb, mrb_value self)
 {
   struct parameters_type {
-    size_t len;
-    const char *name;
+    mrb_sym name;
     int size;
   } *p, parameters_list [] = {
-    {sizeof("req")   - 1, "req",   0},
-    {sizeof("opt")   - 1, "opt",   0},
-    {sizeof("rest")  - 1, "rest",  0},
-    {sizeof("req")   - 1, "req",   0},
-    {sizeof("block") - 1, "block", 0},
-    {0, NULL, 0}
+    {MRB_SYM(req),   0},
+    {MRB_SYM(opt),   0},
+    {MRB_SYM(rest),  0},
+    {MRB_SYM(req),   0},
+    {MRB_SYM(keyrest),   0},
+    {MRB_SYM(block), 0},
+    {MRB_SYM(key),   0},
+    {0, 0}
   };
   const struct RProc *proc = mrb_proc_ptr(self);
   const struct mrb_irep *irep = proc->body.irep;
   mrb_aspec aspec;
   mrb_value parameters;
+  mrb_value krest = mrb_nil_value();
+  mrb_value block = mrb_nil_value();
   int i, j;
   int max = -1;
 
@@ -124,10 +127,8 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
   }
 
   if (!MRB_PROC_STRICT_P(proc)) {
-    parameters_list[0].len = sizeof("opt") - 1;
-    parameters_list[0].name = "opt";
-    parameters_list[3].len = sizeof("opt") - 1;
-    parameters_list[3].name = "opt";
+    parameters_list[0].name = MRB_SYM(opt);
+    parameters_list[3].name = MRB_SYM(opt);
   }
 
   aspec = PEEK_W(irep->iseq+1);
@@ -135,21 +136,23 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
   parameters_list[1].size = MRB_ASPEC_OPT(aspec);
   parameters_list[2].size = MRB_ASPEC_REST(aspec);
   parameters_list[3].size = MRB_ASPEC_POST(aspec);
-  parameters_list[4].size = MRB_ASPEC_BLOCK(aspec);
+  parameters_list[4].size = MRB_ASPEC_KDICT(aspec);
+  parameters_list[5].size = MRB_ASPEC_BLOCK(aspec);
+  parameters_list[6].size = MRB_ASPEC_KEY(aspec);
 
   parameters = mrb_ary_new_capa(mrb, irep->nlocals-1);
 
   max = irep->nlocals-1;
   for (i = 0, p = parameters_list; p->name; p++) {
-    mrb_value sname = mrb_symbol_value(mrb_intern_static(mrb, p->name, p->len));
+    mrb_value sname = mrb_symbol_value(p->name);
 
     for (j = 0; j < p->size; i++, j++) {
       mrb_value a;
 
       a = mrb_ary_new(mrb);
       mrb_ary_push(mrb, a, sname);
-      if (i < max && irep->lv[i].name) {
-        mrb_sym sym = irep->lv[i].name;
+      if (i < max && irep->lv[i]) {
+        mrb_sym sym = irep->lv[i];
         const char *name = mrb_sym_name(mrb, sym);
         switch (name[0]) {
         case '*': case '&':
@@ -159,9 +162,17 @@ mrb_proc_parameters(mrb_state *mrb, mrb_value self)
           break;
         }
       }
+      if (p->name == MRB_SYM(block)) {
+        block = a; continue;
+      }
+      if (p->name == MRB_SYM(keyrest)) {
+        krest = a; continue;
+      }
       mrb_ary_push(mrb, parameters, a);
     }
   }
+  if (!mrb_nil_p(krest)) mrb_ary_push(mrb, parameters, krest);
+  if (!mrb_nil_p(block)) mrb_ary_push(mrb, parameters, block);
   return parameters;
 }
 
diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c
index 10c81b946..0a5df6bd0 100644
--- a/mrbgems/mruby-random/src/random.c
+++ b/mrbgems/mruby-random/src/random.c
@@ -10,16 +10,40 @@
 #include <mruby/data.h>
 #include <mruby/array.h>
 #include <mruby/istruct.h>
-#if INT32_MAX <= INTPTR_MAX
+
+#include <time.h>
+
+/*  Written in 2019 by David Blackman and Sebastiano Vigna ([email protected])
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+
+/* This is xoshiro128++ 1.0, one of our 32-bit all-purpose, rock-solid
+   generators. It has excellent speed, a state size (128 bits) that is
+   large enough for mild parallelism, and it passes all tests we are aware
+   of.
+
+   For generating just single-precision (i.e., 32-bit) floating-point
+   numbers, xoshiro128+ is even faster.
+
+   The state must be seeded so that it is not everywhere zero. */
+
+
+#ifdef MRB_32BIT
 # define XORSHIFT96
 # define NSEEDS 3
+# define SEEDPOS 2
 #else
 # define NSEEDS 4
+# define SEEDPOS 0
 #endif
 #define LASTSEED (NSEEDS-1)
 
-#include <time.h>
-
 typedef struct rand_state {
   uint32_t seed[NSEEDS];
 } rand_state;
@@ -38,16 +62,23 @@ rand_init(rand_state *t)
 static uint32_t
 rand_seed(rand_state *t, uint32_t seed)
 {
-  uint32_t old_seed = t->seed[LASTSEED];
+  uint32_t old_seed = t->seed[SEEDPOS];
   rand_init(t);
-  t->seed[LASTSEED] = seed;
+  t->seed[SEEDPOS] = seed;
   return old_seed;
 }
 
-#ifdef XORSHIFT96
+#ifndef XORSHIFT96
+static inline uint32_t
+rotl(const uint32_t x, int k) {
+  return (x << k) | (x >> (32 - k));
+}
+#endif
+
 static uint32_t
 rand_uint32(rand_state *state)
 {
+#ifdef XORSHIFT96
   uint32_t *seed = state->seed;
   uint32_t x = seed[0];
   uint32_t y = seed[1];
@@ -61,36 +92,29 @@ rand_uint32(rand_state *state)
   seed[2] = z;
 
   return z;
-}
-#else  /* XORSHIFT96 */
-static uint32_t
-rand_uint32(rand_state *state)
-{
-  uint32_t *seed = state->seed;
-  uint32_t x = seed[0];
-  uint32_t y = seed[1];
-  uint32_t z = seed[2];
-  uint32_t w = seed[3];
-  uint32_t t;
+#else
+  uint32_t *s = state->seed;
+  const uint32_t result = rotl(s[0] + s[3], 7) + s[0];
+  const uint32_t t = s[1] << 9;
 
-  t = x ^ (x << 11);
-  x = y; y = z; z = w;
-  w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
-  seed[0] = x;
-  seed[1] = y;
-  seed[2] = z;
-  seed[3] = w;
+  s[2] ^= s[0];
+  s[3] ^= s[1];
+  s[1] ^= s[2];
+  s[0] ^= s[3];
 
-  return w;
-}
+  s[2] ^= t;
+  s[3] = rotl(s[3], 11);
+
+  return result;
 #endif  /* XORSHIFT96 */
+  }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static double
 rand_real(rand_state *t)
 {
   uint32_t x = rand_uint32(t);
-  return x*(1.0/4294967295.0);
+  return x*(1.0/4294967296.0);
 }
 #endif
 
@@ -99,15 +123,15 @@ random_rand(mrb_state *mrb, rand_state *t, mrb_value max)
 {
   mrb_value value;
 
-  if (mrb_fixnum(max) == 0) {
-#ifndef MRB_WITHOUT_FLOAT
+  if (mrb_integer(max) == 0) {
+#ifndef MRB_NO_FLOAT
     value = mrb_float_value(mrb, rand_real(t));
 #else
     mrb_raise(mrb, E_ARGUMENT_ERROR, "Float not supported");
 #endif
   }
   else {
-    value = mrb_fixnum_value(rand_uint32(t) % mrb_fixnum(max));
+    value = mrb_int_value(mrb, rand_uint32(t) % mrb_integer(max));
   }
 
   return value;
@@ -125,7 +149,7 @@ get_opt(mrb_state* mrb)
     mrb_int i;
 
     arg = mrb_to_int(mrb, arg);
-    i = mrb_fixnum(arg);
+    i = mrb_integer(arg);
     if (i < 0) {
       arg = mrb_fixnum_value(0 - i);
     }
@@ -135,7 +159,7 @@ get_opt(mrb_state* mrb)
 
 static void
 random_check(mrb_state *mrb, mrb_value random) {
-  struct RClass *c = mrb_class_get(mrb, "Random");
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Random));
   if (!mrb_obj_is_kind_of(mrb, random, c) || !mrb_istruct_p(random)) {
     mrb_raise(mrb, E_TYPE_ERROR, "Random instance required");
   }
@@ -144,7 +168,7 @@ random_check(mrb_state *mrb, mrb_value random) {
 static mrb_value
 random_default(mrb_state *mrb) {
   struct RClass *c = mrb_class_get(mrb, "Random");
-  mrb_value d = mrb_const_get(mrb, mrb_obj_value(c), mrb_intern_lit(mrb, "DEFAULT"));
+  mrb_value d = mrb_const_get(mrb, mrb_obj_value(c), MRB_SYM(DEFAULT));
   if (!mrb_obj_is_kind_of(mrb, d, c)) {
     mrb_raise(mrb, E_TYPE_ERROR, "Random::DEFAULT replaced");
   }
@@ -167,7 +191,7 @@ random_m_init(mrb_state *mrb, mrb_value self)
     rand_init(t);
   }
   else {
-    rand_seed(t, (uint32_t)mrb_fixnum(seed));
+    rand_seed(t, (uint32_t)mrb_integer(seed));
   }
 
   return self;
@@ -196,11 +220,11 @@ random_m_srand(mrb_state *mrb, mrb_value self)
     seed = (uint32_t)time(NULL) + rand_uint32(t);
   }
   else {
-    seed = (uint32_t)mrb_fixnum(sv);
+    seed = (uint32_t)mrb_integer(sv);
   }
   old_seed = rand_seed(t, seed);
 
-  return mrb_fixnum_value((mrb_int)old_seed);
+  return mrb_int_value(mrb, (mrb_int)old_seed);
 }
 
 /*
@@ -263,7 +287,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
       mrb_value *ptr = RARRAY_PTR(ary);
       mrb_value tmp;
 
-      j = mrb_fixnum(random_rand(mrb, random, max));
+      j = mrb_integer(random_rand(mrb, random, max));
 
       tmp = ptr[i];
       ptr[i] = ptr[j];
@@ -348,16 +372,18 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary)
         r = (mrb_int)(rand_uint32(random) % len);
 
         for (j=0; j<i; j++) {
-          if (mrb_fixnum(RARRAY_PTR(result)[j]) == r) {
+          if (mrb_integer(RARRAY_PTR(result)[j]) == r) {
             goto retry;         /* retry if duplicate */
           }
         }
         break;
       }
-      mrb_ary_push(mrb, result, mrb_fixnum_value(r));
+      mrb_ary_push(mrb, result, mrb_int_value(mrb, r));
     }
     for (i=0; i<n; i++) {
-      mrb_ary_set(mrb, result, i, RARRAY_PTR(ary)[mrb_fixnum(RARRAY_PTR(result)[i])]);
+      mrb_int idx = mrb_integer(RARRAY_PTR(result)[i]);
+      mrb_value elem = RARRAY_PTR(ary)[idx];
+      mrb_ary_set(mrb, result, i, elem);
     }
     return result;
   }
@@ -383,7 +409,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb)
   struct RClass *random;
   struct RClass *array = mrb->array_class;
 
-  mrb_assert(sizeof(rand_state) <= ISTRUCT_DATA_SIZE);
+  mrb_static_assert1(sizeof(rand_state) <= ISTRUCT_DATA_SIZE);
 
   mrb_define_method(mrb, mrb->kernel_module, "rand", random_f_rand, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, mrb->kernel_module, "srand", random_f_srand, MRB_ARGS_OPT(1));
@@ -401,7 +427,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb)
   mrb_define_method(mrb, array, "shuffle!", mrb_ary_shuffle_bang, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, array, "sample", mrb_ary_sample, MRB_ARGS_OPT(2));
 
-  mrb_const_set(mrb, mrb_obj_value(random), mrb_intern_lit(mrb, "DEFAULT"),
+  mrb_const_set(mrb, mrb_obj_value(random), MRB_SYM(DEFAULT),
           mrb_obj_new(mrb, random, 0, NULL));
 }
 
diff --git a/mrbgems/mruby-random/test/random.rb b/mrbgems/mruby-random/test/random.rb
index cf4a55141..f3067748b 100644
--- a/mrbgems/mruby-random/test/random.rb
+++ b/mrbgems/mruby-random/test/random.rb
@@ -32,8 +32,8 @@ assert("Random.srand") do
 end
 
 assert("return class of Kernel.rand") do
-  assert_kind_of(Fixnum, rand(3))
-  assert_kind_of(Fixnum, rand(1.5))
+  assert_kind_of(Integer, rand(3))
+  assert_kind_of(Integer, rand(1.5))
   assert_kind_of(Float, rand)
   assert_kind_of(Float, rand(0.5))
 end
diff --git a/mrbgems/mruby-range-ext/mrblib/range.rb b/mrbgems/mruby-range-ext/mrblib/range.rb
index a213beb57..fadddc343 100644
--- a/mrbgems/mruby-range-ext/mrblib/range.rb
+++ b/mrbgems/mruby-range-ext/mrblib/range.rb
@@ -33,7 +33,7 @@ class Range
 
     # fast path for numerics
     if val.kind_of?(Numeric) && last.kind_of?(Numeric)
-      raise TypeError if exclude_end? && !last.kind_of?(Fixnum)
+      raise TypeError if exclude_end? && !last.kind_of?(Integer)
       return nil if val > last
       return nil if val == last && exclude_end?
 
diff --git a/mrbgems/mruby-range-ext/src/range.c b/mrbgems/mruby-range-ext/src/range.c
index 2a0b4e97d..0f2cc6119 100644
--- a/mrbgems/mruby-range-ext/src/range.c
+++ b/mrbgems/mruby-range-ext/src/range.c
@@ -81,8 +81,8 @@ range_last(mrb_state *mrb, mrb_value range)
     return mrb_range_end(mrb, range);
   }
 
-  array = mrb_funcall(mrb, range, "to_a", 0);
-  return mrb_funcall(mrb, array, "last", 1, mrb_to_int(mrb, num));
+  array = mrb_funcall_id(mrb, range, MRB_SYM(to_a), 0);
+  return mrb_funcall_id(mrb, array, MRB_SYM(last), 1, mrb_to_int(mrb, num));
 }
 
 /*
@@ -96,7 +96,7 @@ range_last(mrb_state *mrb, mrb_value range)
  *    ('a'..'z').size  #=> nil
  */
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static mrb_value
 range_size(mrb_state *mrb, mrb_value range)
 {
@@ -109,8 +109,8 @@ range_size(mrb_state *mrb, mrb_value range)
   beg = RANGE_BEG(r);
   end = RANGE_END(r);
   excl = RANGE_EXCL(r);
-  if (mrb_fixnum_p(beg)) {
-    beg_f = (mrb_float)mrb_fixnum(beg);
+  if (mrb_integer_p(beg)) {
+    beg_f = (mrb_float)mrb_integer(beg);
   }
   else if (mrb_float_p(beg)) {
     beg_f = mrb_float(beg);
@@ -118,8 +118,8 @@ range_size(mrb_state *mrb, mrb_value range)
   else {
     num_p = FALSE;
   }
-  if (mrb_fixnum_p(end)) {
-    end_f = (mrb_float)mrb_fixnum(end);
+  if (mrb_integer_p(end)) {
+    end_f = (mrb_float)mrb_integer(end);
   }
   else if (mrb_float_p(end)) {
     end_f = mrb_float(end);
@@ -161,16 +161,16 @@ range_size(mrb_state *mrb, mrb_value range)
   end = RANGE_END(r);
   excl = RANGE_EXCL(r) ? 0 : 1;
 
-  if (mrb_fixnum_p(beg) && mrb_fixnum_p(end)) {
-    mrb_int a = mrb_fixnum(beg);
-    mrb_int b = mrb_fixnum(end);
+  if (mrb_integer_p(beg) && mrb_integer_p(end)) {
+    mrb_int a = mrb_integer(beg);
+    mrb_int b = mrb_integer(end);
     mrb_int c = b - a + excl;
 
     return mrb_fixnum_value(c);
   }
   return mrb_nil_value();
 }
-#endif /* MRB_WITHOUT_FLOAT */
+#endif /* MRB_NO_FLOAT */
 
 void
 mrb_mruby_range_ext_gem_init(mrb_state* mrb)
diff --git a/mrbgems/mruby-rational/mrblib/rational.rb b/mrbgems/mruby-rational/mrblib/rational.rb
index b65f77e2f..febabbae7 100644
--- a/mrbgems/mruby-rational/mrblib/rational.rb
+++ b/mrbgems/mruby-rational/mrblib/rational.rb
@@ -48,11 +48,11 @@ class Rational < Numeric
   end
 
   def <=>(rhs)
-    if rhs.is_a?(Integral)
+    case rhs
+    when Integer, Float
       return numerator <=> rhs if denominator == 1
       rhs = Rational(rhs)
     end
-
     case rhs
     when Rational
       (numerator * rhs.denominator - denominator * rhs.numerator) <=> 0
@@ -65,14 +65,13 @@ class Rational < Numeric
 
   def ==(rhs)
     return true if self.equal?(rhs)
-    if rhs.is_a?(Integral) && denominator == 1
-      return numerator == rhs
-    end
-    if rhs.is_a?(Rational)
-      numerator * rhs.denominator == denominator * rhs.numerator
-    else
-      rhs == self
+    case rhs
+    when Integer, Float
+      return numerator == rhs if denominator == 1
+    when Rational
+      return numerator * rhs.denominator == denominator * rhs.numerator
     end
+    rhs == self
   end
 end
 
@@ -83,16 +82,9 @@ class Numeric
 end
 
 module Kernel
-  def Rational(numerator, denominator = 1)
-    a = numerator
-    b = denominator
-    a, b = b, a % b until b == 0
-    Rational._new(numerator.div(a), denominator.div(a))
-  end
-
   [:+, :-, :*, :/, :<=>, :==, :<, :<=, :>, :>=].each do |op|
     original_operator_name = :"__original_operator_#{op}_rational"
-    Fixnum.instance_eval do
+    Integer.instance_eval do
       alias_method original_operator_name, op
       define_method op do |rhs|
         if rhs.is_a? Rational
diff --git a/mrbgems/mruby-rational/src/rational.c b/mrbgems/mruby-rational/src/rational.c
index 676a1dc82..d5dd7adc4 100644
--- a/mrbgems/mruby-rational/src/rational.c
+++ b/mrbgems/mruby-rational/src/rational.c
@@ -60,83 +60,128 @@ static mrb_value
 rational_numerator(mrb_state *mrb, mrb_value self)
 {
   struct mrb_rational *p = rational_ptr(mrb, self);
-  return mrb_fixnum_value(p->numerator);
+  return mrb_int_value(mrb, p->numerator);
 }
 
 static mrb_value
 rational_denominator(mrb_state *mrb, mrb_value self)
 {
   struct mrb_rational *p = rational_ptr(mrb, self);
-  return mrb_fixnum_value(p->denominator);
+  return mrb_int_value(mrb, p->denominator);
 }
 
 static mrb_value
 rational_new(mrb_state *mrb, mrb_int numerator, mrb_int denominator)
 {
-  struct RClass *c = mrb_class_get(mrb, "Rational");
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Rational));
   struct mrb_rational *p;
   struct RBasic *rat = rational_alloc(mrb, c, &p);
+  if (denominator < 0) {
+    numerator *= -1;
+    denominator *= -1;
+  }
   p->numerator = numerator;
   p->denominator = denominator;
   MRB_SET_FROZEN_FLAG(rat);
   return mrb_obj_value(rat);
 }
 
+#ifndef MRB_NO_FLOAT
+#include <math.h>
+/* f : number to convert.
+ * num, denom: returned parts of the rational.
+ * md: max denominator value.  Note that machine floating point number
+ *     has a finite resolution (10e-16 ish for 64 bit double), so specifying
+ *     a "best match with minimal error" is often wrong, because one can
+ *     always just retrieve the significand and return that divided by 
+ *     2**52, which is in a sense accurate, but generally not very useful:
+ *     1.0/7.0 would be "2573485501354569/18014398509481984", for example.
+ */
+#ifdef MRB_INT32
+typedef float rat_float;
+#else
+typedef double rat_float;
+#endif
+static mrb_value
+rational_new_f(mrb_state *mrb, mrb_float f0)
+{
+  rat_float f = (rat_float)f0;
+  mrb_int md = 1000000;
+  /*  a: continued fraction coefficients. */
+  mrb_int a, h[3] = { 0, 1, 0 }, k[3] = { 1, 0, 0 };
+  mrb_int x, d;
+  int64_t n = 1;
+  int i, neg = 0;
+
+  if (f < 0) { neg = 1; f = -f; }
+  while (f != floor(f)) { n <<= 1; f *= 2; }
+  d = (mrb_int)f;
+ 
+  /* continued fraction and check denominator each step */
+  for (i = 0; i < 64; i++) {
+    a = n ? d / n : 0;
+    if (i && !a) break;
+ 
+    x = d; d = n; n = x % n;
+ 
+    x = a;
+    if (k[1] * a + k[0] >= md) {
+      x = (md - k[0]) / k[1];
+      if (x * 2 >= a || k[1] >= md)
+        i = 65;
+      else
+        break;
+    }
+
+    h[2] = x * h[1] + h[0]; h[0] = h[1]; h[1] = h[2];
+    k[2] = x * k[1] + k[0]; k[0] = k[1]; k[1] = k[2];
+  }
+  return rational_new(mrb, (neg ? -h[1] : h[1]), k[1]);
+}
+#endif
+
 static mrb_value
 rational_s_new(mrb_state *mrb, mrb_value self)
 {
   mrb_int numerator, denominator;
 
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_get_args(mrb, "ii", &numerator, &denominator);
 #else
 
-#define DROP_PRECISION(f, num, denom) \
-  do { \
-      while (f < (mrb_float)MRB_INT_MIN || f > (mrb_float)MRB_INT_MAX) { \
-        num /= 2; \
-        denom /= 2; \
-      } \
-  } while (0)
-
-  mrb_value numv, denomv;
+ mrb_value numv, denomv;
 
   mrb_get_args(mrb, "oo", &numv, &denomv);
-  if (mrb_fixnum_p(numv)) {
-    numerator = mrb_fixnum(numv);
+  if (mrb_integer_p(numv)) {
+    numerator = mrb_integer(numv);
 
-    if (mrb_fixnum_p(denomv)) {
-      denominator = mrb_fixnum(denomv);
+    if (mrb_integer_p(denomv)) {
+      denominator = mrb_integer(denomv);
     }
     else {
+      mrb_float numf = (mrb_float)numerator;
       mrb_float denomf = mrb_to_flo(mrb, denomv);
 
-      DROP_PRECISION(denomf, numerator, denomf);
-      denominator = (mrb_int)denomf;
+      return rational_new_f(mrb, numf/denomf);
     }
   }
   else {
     mrb_float numf = mrb_to_flo(mrb, numv);
+    mrb_float denomf;
 
-    if (mrb_fixnum_p(denomv)) {
-      denominator = mrb_fixnum(denomv);
+    if (mrb_integer_p(denomv)) {
+      denomf = (mrb_float)mrb_integer(denomv);
     }
     else {
-      mrb_float denomf = mrb_to_flo(mrb, denomv);
-
-      DROP_PRECISION(denomf, numf, denomf);
-      denominator = (mrb_int)denomf;
+      denomf = mrb_to_flo(mrb, denomv);
     }
-
-    DROP_PRECISION(numf, numf, denominator);
-    numerator = (mrb_int)numf;
+    return rational_new_f(mrb, numf/denomf);
   }
 #endif
-
   return rational_new(mrb, numerator, denominator);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static mrb_value
 rational_to_f(mrb_state *mrb, mrb_value self)
 {
@@ -154,7 +199,7 @@ rational_to_i(mrb_state *mrb, mrb_value self)
   if (p->denominator == 0) {
     mrb_raise(mrb, mrb->eStandardError_class, "divided by 0");
   }
-  return mrb_fixnum_value(p->numerator / p->denominator);
+  return mrb_int_value(mrb, p->numerator / p->denominator);
 }
 
 static mrb_value
@@ -176,14 +221,50 @@ rational_negative_p(mrb_state *mrb, mrb_value self)
 static mrb_value
 fix_to_r(mrb_state *mrb, mrb_value self)
 {
-  return rational_new(mrb, mrb_fixnum(self), 1);
+  return rational_new(mrb, mrb_integer(self), 1);
+}
+
+static mrb_value
+rational_m_int(mrb_state *mrb, mrb_int n, mrb_int d)
+{
+  mrb_int a, b;
+
+  a = n;
+  b = d;
+  while (b != 0) {
+    mrb_int tmp = b;
+    b = a % b;
+    a = tmp;
+  }
+  return rational_new(mrb, n/a, d/a);
+}
+
+static mrb_value
+rational_m(mrb_state *mrb, mrb_value self)
+{
+#ifdef MRB_NO_FLOAT
+  mrb_int n, d = 1;
+  mrb_get_args(mrb, "i|i", &n, &d);
+  return rational_m_int(mrb, n, d);
+#else
+  mrb_value a, b = mrb_fixnum_value(1);
+  mrb_get_args(mrb, "o|o", &a, &b);
+  if (mrb_integer_p(a) && mrb_integer_p(b)) {
+    return rational_m_int(mrb, mrb_integer(a), mrb_integer(b));
+  }
+  else {
+    mrb_float x = mrb_to_flo(mrb, a);
+    mrb_float y = mrb_to_flo(mrb, b);
+    return rational_new_f(mrb, x/y);
+  }
+#endif
 }
 
 void mrb_mruby_rational_gem_init(mrb_state *mrb)
 {
   struct RClass *rat;
 
-  rat = mrb_define_class(mrb, "Rational", mrb_class_get(mrb, "Numeric"));
+  rat = mrb_define_class_id(mrb, MRB_SYM(Rational), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
 #ifdef RATIONAL_USE_ISTRUCT
   MRB_SET_INSTANCE_TT(rat, MRB_TT_ISTRUCT);
   mrb_assert(sizeof(struct mrb_rational) < ISTRUCT_DATA_SIZE);
@@ -194,13 +275,14 @@ void mrb_mruby_rational_gem_init(mrb_state *mrb)
   mrb_define_class_method(mrb, rat, "_new", rational_s_new, MRB_ARGS_REQ(2));
   mrb_define_method(mrb, rat, "numerator", rational_numerator, MRB_ARGS_NONE());
   mrb_define_method(mrb, rat, "denominator", rational_denominator, MRB_ARGS_NONE());
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_define_method(mrb, rat, "to_f", rational_to_f, MRB_ARGS_NONE());
 #endif
   mrb_define_method(mrb, rat, "to_i", rational_to_i, MRB_ARGS_NONE());
   mrb_define_method(mrb, rat, "to_r", rational_to_r, MRB_ARGS_NONE());
   mrb_define_method(mrb, rat, "negative?", rational_negative_p, MRB_ARGS_NONE());
-  mrb_define_method(mrb, mrb->fixnum_class, "to_r", fix_to_r, MRB_ARGS_NONE());
+  mrb_define_method(mrb, mrb->integer_class, "to_r", fix_to_r, MRB_ARGS_NONE());
+  mrb_define_method(mrb, mrb->kernel_module, "Rational", rational_m, MRB_ARGS_ARG(1,1));
 }
 
 void
diff --git a/mrbgems/mruby-rational/test/rational.rb b/mrbgems/mruby-rational/test/rational.rb
index a8ebb8ea2..3fb4e4e82 100644
--- a/mrbgems/mruby-rational/test/rational.rb
+++ b/mrbgems/mruby-rational/test/rational.rb
@@ -143,7 +143,7 @@ assert 'Rational#==, Rational#!=' do
   assert_equal_rational(false, 1r, ComplexLikeNumeric.new(2))
 end
 
-assert 'Fixnum#==(Rational), Fixnum#!=(Rational)' do
+assert 'Integer#==(Rational), Integer#!=(Rational)' do
   assert_equal_rational(true, 2, Rational(4,2))
   assert_equal_rational(true, -2, Rational(-4,2))
   assert_equal_rational(true, -2, Rational(4,-2))
@@ -186,7 +186,7 @@ assert 'Rational#<=>' do
   assert_raise(NoMethodError) { 1r <=> ComplexLikeNumeric.new(2) }
 end
 
-assert 'Fixnum#<=>(Rational)' do
+assert 'Integer#<=>(Rational)' do
   assert_cmp(-1, -2, Rational(-9,5))
   assert_cmp(0, 5, 5r)
   assert_cmp(1, 3, Rational(8,3))
@@ -210,7 +210,7 @@ assert 'Rational#<' do
   assert_raise(ArgumentError) { 1r < "2" }
 end
 
-assert 'Fixnum#<(Rational)' do
+assert 'Integer#<(Rational)' do
   assert_not_operator(1, :<, Rational(2,3))
   assert_not_operator(2, :<, 2r)
   assert_operator(-3, :<, Rational(2,3))
@@ -234,7 +234,7 @@ assert 'Rational#<=' do
   assert_raise(ArgumentError) { 1r <= "2" }
 end
 
-assert 'Fixnum#<=(Rational)' do
+assert 'Integer#<=(Rational)' do
   assert_not_operator(1, :<=, Rational(2,3))
   assert_operator(2, :<=, 2r)
   assert_operator(-3, :<=, Rational(2,3))
@@ -258,7 +258,7 @@ assert 'Rational#>' do
   assert_raise(ArgumentError) { 1r > "2" }
 end
 
-assert 'Fixnum#>(Rational)' do
+assert 'Integer#>(Rational)' do
   assert_operator(1, :>, Rational(2,3))
   assert_not_operator(2, :>, 2r)
   assert_not_operator(-3, :>, Rational(2,3))
@@ -282,7 +282,7 @@ assert 'Rational#>=' do
   assert_raise(ArgumentError) { 1r >= "2" }
 end
 
-assert 'Fixnum#>=(Rational)' do
+assert 'Integer#>=(Rational)' do
   assert_operator(1, :>=, Rational(2,3))
   assert_operator(2, :>=, 2r)
   assert_not_operator(-3, :>=, Rational(2,3))
diff --git a/mrbgems/mruby-sleep/src/mrb_sleep.c b/mrbgems/mruby-sleep/src/mrb_sleep.c
index a653242d1..7771db56b 100644
--- a/mrbgems/mruby-sleep/src/mrb_sleep.c
+++ b/mrbgems/mruby-sleep/src/mrb_sleep.c
@@ -44,7 +44,7 @@ mrb_f_sleep(mrb_state *mrb, mrb_value self)
 {
     time_t beg = time(0);
     time_t end;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     mrb_float sec;
 
     mrb_get_args(mrb, "f", &sec);
diff --git a/mrbgems/mruby-socket/src/socket.c b/mrbgems/mruby-socket/src/socket.c
index a819dcb29..0afbca521 100644
--- a/mrbgems/mruby-socket/src/socket.c
+++ b/mrbgems/mruby-socket/src/socket.c
@@ -53,7 +53,7 @@
 #endif
 #endif
 
-#define E_SOCKET_ERROR             (mrb_class_get(mrb, "SocketError"))
+#define E_SOCKET_ERROR             mrb_class_get_id(mrb, MRB_SYM(SocketError))
 
 #if !defined(mrb_cptr)
 #define mrb_cptr_value(m,p) mrb_voidp_value((m),(p))
@@ -140,50 +140,50 @@ mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
 
   if (mrb_string_p(service)) {
     servname = RSTRING_CSTR(mrb, service);
-  } else if (mrb_fixnum_p(service)) {
+  } else if (mrb_integer_p(service)) {
     servname = RSTRING_PTR(mrb_fixnum_to_str(mrb, service, 10));
   } else if (mrb_nil_p(service)) {
     servname = NULL;
   } else {
-    mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Fixnum, or nil");
+    mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Integer, or nil");
   }
 
   memset(&hints, 0, sizeof(hints));
   hints.ai_flags = (int)flags;
 
-  if (mrb_fixnum_p(family)) {
-    hints.ai_family = (int)mrb_fixnum(family);
+  if (mrb_integer_p(family)) {
+    hints.ai_family = (int)mrb_integer(family);
   }
 
-  if (mrb_fixnum_p(socktype)) {
-    hints.ai_socktype = (int)mrb_fixnum(socktype);
+  if (mrb_integer_p(socktype)) {
+    hints.ai_socktype = (int)mrb_integer(socktype);
   }
 
-  if (mrb_fixnum_p(protocol)) {
-    hints.ai_protocol = (int)mrb_fixnum(protocol);
+  if (mrb_integer_p(protocol)) {
+    hints.ai_protocol = (int)mrb_integer(protocol);
   }
 
-  lastai = mrb_cv_get(mrb, klass, mrb_intern_lit(mrb, "_lastai"));
+  lastai = mrb_cv_get(mrb, klass, MRB_SYM(_lastai));
   if (mrb_cptr_p(lastai)) {
     freeaddrinfo((struct addrinfo*)mrb_cptr(lastai));
-    mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+    mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_nil_value());
   }
 
   error = getaddrinfo(hostname, servname, &hints, &res0);
   if (error) {
     mrb_raisef(mrb, E_SOCKET_ERROR, "getaddrinfo: %s", gai_strerror(error));
   }
-  mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_cptr_value(mrb, res0));
+  mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_cptr_value(mrb, res0));
 
   for (res = res0; res != NULL; res = res->ai_next) {
     sa = mrb_str_new(mrb, (char*)res->ai_addr, res->ai_addrlen);
-    ai = mrb_funcall(mrb, klass, "new", 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
+    ai = mrb_funcall_id(mrb, klass, MRB_SYM(new), 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
     mrb_ary_push(mrb, ary, ai);
     mrb_gc_arena_restore(mrb, arena_idx);
   }
 
   freeaddrinfo(res0);
-  mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+  mrb_cv_set(mrb, klass, MRB_SYM(_lastai), mrb_nil_value());
 
   return ary;
 }
@@ -200,7 +200,7 @@ mrb_addrinfo_getnameinfo(mrb_state *mrb, mrb_value self)
   host = mrb_str_buf_new(mrb, NI_MAXHOST);
   serv = mrb_str_buf_new(mrb, NI_MAXSERV);
 
-  sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr"));
+  sastr = mrb_iv_get(mrb, self, MRB_QSYM(0_sockaddr));
   if (!mrb_string_p(sastr)) {
     mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr");
   }
@@ -222,7 +222,7 @@ mrb_addrinfo_unix_path(mrb_state *mrb, mrb_value self)
 {
   mrb_value sastr;
 
-  sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr"));
+  sastr = mrb_iv_get(mrb, self, MRB_QSYM(0_sockaddr));
   if (((struct sockaddr *)RSTRING_PTR(sastr))->sa_family != AF_UNIX)
     mrb_raise(mrb, E_SOCKET_ERROR, "need AF_UNIX address");
   if (RSTRING_LEN(sastr) < (mrb_int)offsetof(struct sockaddr_un, sun_path) + 1) {
@@ -269,7 +269,7 @@ sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen)
 static int
 socket_fd(mrb_state *mrb, mrb_value sock)
 {
-  return (int)mrb_fixnum(mrb_funcall(mrb, sock, "fileno", 0));
+  return (int)mrb_integer(mrb_funcall_id(mrb, sock, MRB_SYM(fileno), 0));
 }
 
 static int
@@ -347,10 +347,10 @@ mrb_basicsocket_getsockopt(mrb_state *mrb, mrb_value self)
   optlen = sizeof(opt);
   if (getsockopt(s, (int)level, (int)optname, opt, &optlen) == -1)
     mrb_sys_fail(mrb, "getsockopt");
-  c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Socket")), mrb_intern_lit(mrb, "Option"));
+  c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get_id(mrb, MRB_SYM(Socket))), MRB_SYM(Option));
   family = socket_family(s);
   data = mrb_str_new(mrb, opt, optlen);
-  return mrb_funcall(mrb, c, "new", 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data);
+  return mrb_funcall_id(mrb, c, MRB_SYM(new), 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data);
 }
 
 static mrb_value
@@ -449,21 +449,21 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
 
   argc = mrb_get_args(mrb, "o|io", &so, &optname, &optval);
   if (argc == 3) {
-    if (!mrb_fixnum_p(so)) {
+    if (!mrb_integer_p(so)) {
       mrb_raise(mrb, E_ARGUMENT_ERROR, "level is not an integer");
     }
-    level = mrb_fixnum(so);
+    level = mrb_integer(so);
     if (mrb_string_p(optval)) {
       /* that's good */
     } else if (mrb_true_p(optval) || mrb_false_p(optval)) {
       mrb_int i = mrb_test(optval) ? 1 : 0;
       optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
-    } else if (mrb_fixnum_p(optval)) {
+    } else if (mrb_integer_p(optval)) {
       if (optname == IP_MULTICAST_TTL || optname == IP_MULTICAST_LOOP) {
-        char uc = (char)mrb_fixnum(optval);
+        char uc = (char)mrb_integer(optval);
         optval = mrb_str_new(mrb, &uc, sizeof(uc));
       } else {
-        mrb_int i = mrb_fixnum(optval);
+        mrb_int i = mrb_integer(optval);
         optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
       }
     } else {
@@ -472,9 +472,9 @@ mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
   } else if (argc == 1) {
     if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0)
       mrb_raise(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option");
-    level = mrb_fixnum(mrb_funcall(mrb, so, "level", 0));
-    optname = mrb_fixnum(mrb_funcall(mrb, so, "optname", 0));
-    optval = mrb_funcall(mrb, so, "data", 0);
+    level = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(level), 0));
+    optname = mrb_integer(mrb_funcall_id(mrb, so, MRB_SYM(optname), 0));
+    optval = mrb_funcall_id(mrb, so, MRB_SYM(data), 0);
   } else {
     mrb_argnum_error(mrb, argc, 3, 3);
   }
@@ -842,7 +842,7 @@ mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self)
   n = send(sd, RSTRING_PTR(str), (int)RSTRING_LEN(str), 0);
   if (n == SOCKET_ERROR)
     mrb_sys_fail(mrb, "send");
-  return mrb_fixnum_value(n);
+  return mrb_int_value(mrb, n);
 }
 
 #endif
@@ -862,14 +862,14 @@ mrb_mruby_socket_gem_init(mrb_state* mrb)
 #endif
 
   ai = mrb_define_class(mrb, "Addrinfo", mrb->object_class);
-  mrb_mod_cv_set(mrb, ai, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
+  mrb_mod_cv_set(mrb, ai, MRB_SYM(_lastai), mrb_nil_value());
   mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(4));
   mrb_define_method(mrb, ai, "getnameinfo", mrb_addrinfo_getnameinfo, MRB_ARGS_OPT(1));
 #ifndef _WIN32
   mrb_define_method(mrb, ai, "unix_path", mrb_addrinfo_unix_path, MRB_ARGS_NONE());
 #endif
 
-  io = mrb_class_get(mrb, "IO");
+  io = mrb_class_get_id(mrb, MRB_SYM(IO));
 
   bsock = mrb_define_class(mrb, "BasicSocket", io);
   mrb_define_method(mrb, bsock, "_recvfrom", mrb_basicsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
@@ -938,7 +938,7 @@ mrb_mruby_socket_gem_init(mrb_state* mrb)
 
 #define define_const(SYM) \
   do {								\
-    mrb_define_const(mrb, constants, #SYM, mrb_fixnum_value(SYM));	\
+    mrb_define_const(mrb, constants, #SYM, mrb_int_value(mrb, SYM));	\
   } while (0)
 
 #include "const.cstub"
@@ -948,7 +948,7 @@ void
 mrb_mruby_socket_gem_final(mrb_state* mrb)
 {
   mrb_value ai;
-  ai = mrb_mod_cv_get(mrb, mrb_class_get(mrb, "Addrinfo"), mrb_intern_lit(mrb, "_lastai"));
+  ai = mrb_mod_cv_get(mrb, mrb_class_get_id(mrb, MRB_SYM(Addrinfo)), MRB_SYM(_lastai));
   if (mrb_cptr_p(ai)) {
     freeaddrinfo((struct addrinfo*)mrb_cptr(ai));
   }
diff --git a/mrbgems/mruby-sprintf/src/kernel.c b/mrbgems/mruby-sprintf/src/kernel.c
deleted file mode 100644
index a0f0a78ba..000000000
--- a/mrbgems/mruby-sprintf/src/kernel.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
-** kernel.c - Kernel module suppliment
-**
-** See Copyright Notice in mruby.h
-*/
-
-#include <mruby.h>
-
-mrb_value mrb_f_sprintf(mrb_state *mrb, mrb_value obj); /* in sprintf.c */
-
-void
-mrb_mruby_sprintf_gem_init(mrb_state* mrb)
-{
-  struct RClass *krn;
-
-  if (mrb->kernel_module == NULL) {
-    mrb->kernel_module = mrb_define_module(mrb, "Kernel"); /* Might be PARANOID. */
-  }
-  krn = mrb->kernel_module;
-
-  mrb_define_method(mrb, krn, "sprintf", mrb_f_sprintf, MRB_ARGS_REQ(1)|MRB_ARGS_REST());
-  mrb_define_method(mrb, krn, "format",  mrb_f_sprintf, MRB_ARGS_REQ(1)|MRB_ARGS_REST());
-}
-
-void
-mrb_mruby_sprintf_gem_final(mrb_state* mrb)
-{
-  /* nothing to do. */
-}
-
diff --git a/mrbgems/mruby-sprintf/src/sprintf.c b/mrbgems/mruby-sprintf/src/sprintf.c
index bf7a4d725..3ecf11afb 100644
--- a/mrbgems/mruby-sprintf/src/sprintf.c
+++ b/mrbgems/mruby-sprintf/src/sprintf.c
@@ -10,7 +10,7 @@
 #include <mruby/string.h>
 #include <mruby/hash.h>
 #include <mruby/numeric.h>
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #include <math.h>
 #endif
 #include <ctype.h>
@@ -20,7 +20,7 @@
 #define EXTENDSIGN(n, l) (((~0U << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0U << (n)))
 
 mrb_value mrb_str_format(mrb_state *, mrb_int, const mrb_value *, mrb_value);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static void fmt_setup(char*,size_t,int,int,mrb_int,mrb_int);
 #endif
 
@@ -74,7 +74,7 @@ static mrb_value
 mrb_fix2binstr(mrb_state *mrb, mrb_value x, int base)
 {
   char buf[66], *b = buf + sizeof buf;
-  mrb_int num = mrb_fixnum(x);
+  mrb_int num = mrb_integer(x);
   uint64_t val = (uint64_t)num;
   char d;
 
@@ -192,20 +192,14 @@ check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len)
 #define GETNTHARG(nth) \
   ((nth >= argc) ? (mrb_raise(mrb, E_ARGUMENT_ERROR, "too few arguments"), mrb_undef_value()) : argv[nth])
 
-#define GETNAMEARG(id, name, len) (\
+#define CHECKNAMEARG(name, len) (\
   check_name_arg(mrb, posarg, name, len),\
-  (posarg = -2, mrb_hash_fetch(mrb, get_hash(mrb, &hash, argc, argv), id, mrb_undef_value())))
-
-#define GETNUM(n, val) \
-  for (; p < end && ISDIGIT(*p); p++) {\
-    if (n > (MRB_INT_MAX - (*p - '0'))/10) {\
-      mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big"); \
-    } \
-    n = 10 * n + (*p - '0'); \
-  } \
-  if (p >= end) { \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %*[0-9]"); \
-  }
+  posarg = -2)
+
+#define GETNUM(n, val) do { \
+  if (!(p = get_num(mrb, p, end, &(n)))) \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, #val " too big 1"); \
+} while(0)
 
 #define GETASTER(num) do { \
   mrb_value tmp_v; \
@@ -222,12 +216,32 @@ check_name_arg(mrb_state *mrb, int posarg, const char *name, size_t len)
   num = mrb_int(mrb, tmp_v); \
 } while (0)
 
-static mrb_value
+static const char *
+get_num(mrb_state *mrb, const char *p, const char *end, mrb_int *valp)
+{
+  mrb_int next_n = *valp;
+  for (; p < end && ISDIGIT(*p); p++) {
+    if (mrb_int_mul_overflow(10, next_n, &next_n)) {
+      return NULL;
+    }
+    if (MRB_INT_MAX - (*p - '0') < next_n) {
+      return NULL;
+    }
+    next_n += *p - '0';
+  }
+  if (p >= end) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "malformed format string - %%*[0-9]");
+  }
+  *valp = next_n;
+  return p;
+}
+
+static void
 get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
 {
   mrb_value tmp;
 
-  if (!mrb_undef_p(*hash)) return *hash;
+  if (!mrb_undef_p(*hash)) return;
   if (argc != 2) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
   }
@@ -235,7 +249,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
   if (mrb_nil_p(tmp)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "one hash required");
   }
-  return (*hash = tmp);
+  *hash = tmp;
 }
 
 /*
@@ -499,7 +513,7 @@ get_hash(mrb_state *mrb, mrb_value *hash, mrb_int argc, const mrb_value *argv)
  *      # => "1f"
  */
 
-mrb_value
+static mrb_value
 mrb_f_sprintf(mrb_state *mrb, mrb_value obj)
 {
   mrb_int argc;
@@ -577,19 +591,19 @@ mrb_str_format(mrb_state *mrb, mrb_int argc, const mrb_value *argv, mrb_value fm
   mrb_value str;
   mrb_value hash = mrb_undef_value();
 
-#define CHECK_FOR_WIDTH(f)                                                  \
-  if ((f) & FWIDTH) {                                                       \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "width given twice");         \
-  }                                                                         \
-  if ((f) & FPREC0) {                                                       \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "width after precision");     \
+#define CHECK_FOR_WIDTH(f)                                              \
+  if ((f) & FWIDTH) {                                                   \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "width given twice");              \
+    }                                                                   \
+  if ((f) & FPREC0) {                                                   \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "width after precision");          \
   }
-#define CHECK_FOR_FLAGS(f)                                                  \
-  if ((f) & FWIDTH) {                                                       \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after width");          \
-  }                                                                         \
-  if ((f) & FPREC0) {                                                       \
-    mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision");      \
+#define CHECK_FOR_FLAGS(f)                                              \
+  if ((f) & FWIDTH) {                                                   \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after width");               \
+  }                                                                     \
+  if ((f) & FPREC0) {                                                   \
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "flag after precision");           \
   }
 
   ++argc;
@@ -676,7 +690,6 @@ retry:
       case '{': {
         const char *start = p;
         char term = (*p == '<') ? '>' : '}';
-        mrb_value symname;
 
         for (; p < end && *p != term; )
           p++;
@@ -684,10 +697,13 @@ retry:
           mrb_raisef(mrb, E_ARGUMENT_ERROR, "name%l after <%n>",
                      start, p - start + 1, id);
         }
-        symname = mrb_str_new(mrb, start + 1, p - start - 1);
-        id = mrb_intern_str(mrb, symname);
-        nextvalue = GETNAMEARG(mrb_symbol_value(id), start, p - start + 1);
-        if (mrb_undef_p(nextvalue)) {
+        CHECKNAMEARG(start, p - start + 1);
+        get_hash(mrb, &hash, argc, argv);
+        id = mrb_intern_check(mrb, start + 1, p - start - 1);
+        if (id) {
+          nextvalue = mrb_hash_fetch(mrb, hash, mrb_symbol_value(id), mrb_undef_value());
+        }
+        if (!id || mrb_undef_p(nextvalue)) {
           mrb_raisef(mrb, E_KEY_ERROR, "key%l not found", start, p - start + 1);
         }
         if (term == '}') goto format_s;
@@ -748,8 +764,8 @@ retry:
             mrb_raise(mrb, E_ARGUMENT_ERROR, "%c requires a character");
           }
         }
-        else if (mrb_fixnum_p(val)) {
-          mrb_int n = mrb_fixnum(val);
+        else if (mrb_integer_p(val)) {
+          mrb_int n = mrb_integer(val);
 #ifndef MRB_UTF8_STRING
           char buf[1];
 
@@ -763,7 +779,7 @@ retry:
             tmp = mrb_str_new(mrb, buf, 1);
           }
           else {
-            tmp = mrb_funcall(mrb, val, "chr", 0);
+            tmp = mrb_funcall_id(mrb, val, MRB_SYM(chr), 0);
             mrb_check_type(mrb, tmp, MRB_TT_STRING);
           }
 #endif
@@ -863,17 +879,17 @@ retry:
 
   bin_retry:
         switch (mrb_type(val)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
           case MRB_TT_FLOAT:
             val = mrb_flo_to_fixnum(mrb, val);
-            if (mrb_fixnum_p(val)) goto bin_retry;
+            if (mrb_integer_p(val)) goto bin_retry;
             break;
 #endif
           case MRB_TT_STRING:
             val = mrb_str_to_inum(mrb, val, 0, TRUE);
             goto bin_retry;
-          case MRB_TT_FIXNUM:
-            v = mrb_fixnum(val);
+          case MRB_TT_INTEGER:
+            v = mrb_integer(val);
             break;
           default:
             val = mrb_Integer(mrb, val);
@@ -922,10 +938,10 @@ retry:
           s = nbuf;
           if (v < 0) {
             dots = 1;
-            val = mrb_fix2binstr(mrb, mrb_fixnum_value(v), base);
+            val = mrb_fix2binstr(mrb, mrb_int_value(mrb, v), base);
           }
           else {
-            val = mrb_fixnum_to_str(mrb, mrb_fixnum_value(v), base);
+            val = mrb_fixnum_to_str(mrb, mrb_int_value(mrb, v), base);
           }
           strncpy(++s, RSTRING_PTR(val), sizeof(nbuf)-2);
           if (v < 0) {
@@ -1030,7 +1046,7 @@ retry:
       }
       break;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       case 'f':
       case 'g':
       case 'G':
@@ -1131,7 +1147,7 @@ retry:
   return result;
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static void
 fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec)
 {
@@ -1160,3 +1176,16 @@ fmt_setup(char *buf, size_t size, int c, int flags, mrb_int width, mrb_int prec)
   *buf = '\0';
 }
 #endif
+
+void
+mrb_mruby_sprintf_gem_init(mrb_state *mrb)
+{
+  struct RClass *krn = mrb->kernel_module;
+  mrb_define_module_function(mrb, krn, "sprintf", mrb_f_sprintf, MRB_ARGS_ANY());
+  mrb_define_module_function(mrb, krn, "format",  mrb_f_sprintf, MRB_ARGS_ANY());
+}
+
+void
+mrb_mruby_sprintf_gem_final(mrb_state *mrb)
+{
+}
diff --git a/mrbgems/mruby-sprintf/test/sprintf.rb b/mrbgems/mruby-sprintf/test/sprintf.rb
index 0eb51f557..8f99f9cd0 100644
--- a/mrbgems/mruby-sprintf/test/sprintf.rb
+++ b/mrbgems/mruby-sprintf/test/sprintf.rb
@@ -1,5 +1,7 @@
-#assert('Kernel.sprintf') do
-#end
+assert('sprintf invalid') do
+  assert_raise(ArgumentError) { sprintf('%1$*d', 3) }
+  assert_raise(ArgumentError) { sprintf('%1$.*d', 3) }
+end
 
 assert('String#%') do
   assert_equal "one=1", "one=%d" % 1
diff --git a/mrbgems/mruby-string-ext/src/string.c b/mrbgems/mruby-string-ext/src/string.c
index ded34a89e..4b8f99597 100644
--- a/mrbgems/mruby-string-ext/src/string.c
+++ b/mrbgems/mruby-string-ext/src/string.c
@@ -12,7 +12,7 @@
 #define ENC_COMP_P(enc, enc_lit) \
   str_casecmp_p(RSTRING_PTR(enc), RSTRING_LEN(enc), enc_lit, sizeof(enc_lit"")-1)
 
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
 # define mrb_float_p(o) FALSE
 #endif
 
@@ -166,7 +166,7 @@ mrb_str_concat_m(mrb_state *mrb, mrb_value self)
 {
   mrb_value str = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(str) || mrb_float_p(str))
+  if (mrb_integer_p(str) || mrb_float_p(str))
 #ifdef MRB_UTF8_STRING
     str = int_chr_utf8(mrb, str);
 #else
@@ -1231,7 +1231,7 @@ mrb_mruby_string_ext_gem_init(mrb_state* mrb)
 
   mrb_define_method(mrb, s, "__lines",         mrb_str_lines,           MRB_ARGS_NONE());
 
-  mrb_define_method(mrb, mrb_module_get(mrb, "Integral"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, mrb_class_get(mrb, "Integer"), "chr", mrb_int_chr, MRB_ARGS_OPT(1));
 }
 
 void
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index 7fbf9225f..7c6f50090 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -20,7 +20,7 @@
 static struct RClass *
 struct_class(mrb_state *mrb)
 {
-  return mrb_class_get(mrb, "Struct");
+  return mrb_class_get_id(mrb, MRB_SYM(Struct));
 }
 
 static inline mrb_value
@@ -42,7 +42,7 @@ struct_ivar_get(mrb_state *mrb, mrb_value cls, mrb_sym id)
 static mrb_value
 struct_s_members(mrb_state *mrb, struct RClass *klass)
 {
-  mrb_value members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern_lit(mrb, "__members__"));
+  mrb_value members = struct_ivar_get(mrb, mrb_obj_value(klass), MRB_SYM(__members__));
 
   if (mrb_nil_p(members)) {
     mrb_raise(mrb, E_TYPE_ERROR, "uninitialized struct");
@@ -113,7 +113,7 @@ mrb_struct_members(mrb_state *mrb, mrb_value obj)
 static mrb_value
 mrb_struct_ref(mrb_state *mrb, mrb_value obj)
 {
-  mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+  mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0));
   mrb_value *ptr = RSTRUCT_PTR(obj);
 
   if (!ptr) return mrb_nil_value();
@@ -152,7 +152,7 @@ mrb_id_attrset(mrb_state *mrb, mrb_sym id)
 static mrb_value
 mrb_struct_set_m(mrb_state *mrb, mrb_value obj)
 {
-  mrb_int i = mrb_fixnum(mrb_proc_cfunc_env_get(mrb, 0));
+  mrb_int i = mrb_integer(mrb_proc_cfunc_env_get(mrb, 0));
   mrb_value *ptr;
   mrb_value val = mrb_get_arg1(mrb);
 
@@ -214,7 +214,7 @@ make_struct(mrb_state *mrb, mrb_value name, mrb_value members, struct RClass *kl
   }
   MRB_SET_INSTANCE_TT(c, MRB_TT_ARRAY);
   nstr = mrb_obj_value(c);
-  mrb_iv_set(mrb, nstr, mrb_intern_lit(mrb, "__members__"), members);
+  mrb_iv_set(mrb, nstr, MRB_SYM(__members__), members);
 
   mrb_define_class_method(mrb, c, "new", mrb_instance_new, MRB_ARGS_ANY());
   mrb_define_class_method(mrb, c, "[]", mrb_instance_new, MRB_ARGS_ANY());
@@ -310,7 +310,7 @@ num_members(mrb_state *mrb, struct RClass *klass)
 {
   mrb_value members;
 
-  members = struct_ivar_get(mrb, mrb_obj_value(klass), mrb_intern_lit(mrb, "__members__"));
+  members = struct_ivar_get(mrb, mrb_obj_value(klass), MRB_SYM(__members__));
   if (!mrb_array_p(members)) {
     mrb_raise(mrb, E_TYPE_ERROR, "broken members");
   }
@@ -428,12 +428,8 @@ mrb_struct_aref(mrb_state *mrb, mrb_value s)
   mrb_value idx = mrb_get_arg1(mrb);
 
   if (mrb_string_p(idx)) {
-    mrb_value sym = mrb_check_intern_str(mrb, idx);
-
-    if (mrb_nil_p(sym)) {
-      mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%v' in struct", idx);
-    }
-    idx = sym;
+    mrb_sym sym = mrb_intern_str(mrb, idx);
+    idx = mrb_symbol_value(sym);
   }
   if (mrb_symbol_p(idx)) {
     return struct_aref_sym(mrb, s, mrb_symbol(idx));
@@ -495,12 +491,8 @@ mrb_struct_aset(mrb_state *mrb, mrb_value s)
   mrb_get_args(mrb, "oo", &idx, &val);
 
   if (mrb_string_p(idx)) {
-    mrb_value sym = mrb_check_intern_str(mrb, idx);
-
-    if (mrb_nil_p(sym)) {
-      mrb_name_error(mrb, mrb_intern_str(mrb, idx), "no member '%v' in struct", idx);
-    }
-    idx = sym;
+    mrb_sym sym = mrb_intern_str(mrb, idx);
+    idx = mrb_symbol_value(sym);
   }
   if (mrb_symbol_p(idx)) {
     return mrb_struct_aset_sym(mrb, s, mrb_symbol(idx), val);
@@ -604,8 +596,8 @@ mrb_struct_eql(mrb_state *mrb, mrb_value s)
 
 /*
  * call-seq:
- *    struct.length   -> Fixnum
- *    struct.size     -> Fixnum
+ *    struct.length   -> Integer
+ *    struct.size     -> Integer
  *
  * Returns number of struct members.
  */
diff --git a/mrbgems/mruby-test/driver.c b/mrbgems/mruby-test/driver.c
index a5f723927..f780e7e57 100644
--- a/mrbgems/mruby-test/driver.c
+++ b/mrbgems/mruby-test/driver.c
@@ -224,8 +224,8 @@ mrb_init_test_driver(mrb_state *mrb, mrb_bool verbose)
   mrb_define_const(mrb, mrbtest, "FIXNUM_MIN", mrb_fixnum_value(MRB_INT_MIN));
   mrb_define_const(mrb, mrbtest, "FIXNUM_BIT", mrb_fixnum_value(MRB_INT_BIT));
 
-#ifndef MRB_WITHOUT_FLOAT
-#ifdef MRB_USE_FLOAT
+#ifndef MRB_NO_FLOAT
+#ifdef MRB_USE_FLOAT32
   mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-6));
 #else
   mrb_define_const(mrb, mrbtest, "FLOAT_TOLERANCE", mrb_float_value(mrb, 1e-12));
@@ -252,9 +252,9 @@ mrb_t_pass_result(mrb_state *mrb_dst, mrb_state *mrb_src)
 #define TEST_COUNT_PASS(name)                                           \
   do {                                                                  \
     res_src = mrb_gv_get(mrb_src, mrb_intern_lit(mrb_src, "$" #name));  \
-    if (mrb_fixnum_p(res_src)) {                                        \
+    if (mrb_integer_p(res_src)) {                                       \
       mrb_value res_dst = mrb_gv_get(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name)); \
-      mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_fixnum_value(mrb_fixnum(res_dst) + mrb_fixnum(res_src))); \
+      mrb_gv_set(mrb_dst, mrb_intern_lit(mrb_dst, "$" #name), mrb_int_value(mrb_dst, mrb_integer(res_dst) + mrb_integer(res_src))); \
     }                                                                   \
   } while (FALSE)                                                       \
 
diff --git a/mrbgems/mruby-test/mrbgem.rake b/mrbgems/mruby-test/mrbgem.rake
index ced252ae6..0df683f7f 100644
--- a/mrbgems/mruby-test/mrbgem.rake
+++ b/mrbgems/mruby-test/mrbgem.rake
@@ -28,7 +28,7 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
   file assert_c => [assert_rb, build.mrbcfile] do |t|
     mkdir_p File.dirname(t.name)
     open(t.name, 'w') do |f|
-      mrbc.run f, assert_rb, 'mrbtest_assert_irep'
+      mrbc.run f, assert_rb, 'mrbtest_assert_irep', false
     end
   end
 
@@ -58,10 +58,10 @@ MRuby::Gem::Specification.new('mruby-test') do |spec|
         if test_preload.nil?
           f.puts %Q[extern const uint8_t mrbtest_assert_irep[];]
         else
-          g.build.mrbc.run f, test_preload, "gem_test_irep_#{g.funcname}_preload"
+          g.build.mrbc.run f, test_preload, "gem_test_irep_#{g.funcname}_preload", false
         end
         g.test_rbfiles.flatten.each_with_index do |rbfile, i|
-          g.build.mrbc.run f, rbfile, "gem_test_irep_#{g.funcname}_#{i}"
+          g.build.mrbc.run f, rbfile, "gem_test_irep_#{g.funcname}_#{i}", false
         end
         f.puts %Q[void mrb_#{g.funcname}_gem_test(mrb_state *mrb);] unless g.test_objs.empty?
         dep_list.each do |d|
diff --git a/mrbgems/mruby-test/vformat.c b/mrbgems/mruby-test/vformat.c
index e7ada02da..d73e52311 100644
--- a/mrbgems/mruby-test/vformat.c
+++ b/mrbgems/mruby-test/vformat.c
@@ -48,7 +48,7 @@ vf_s_format_d(mrb_state *mrb, mrb_value klass)
   return mrb_format(mrb, fmt, d);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /* f float */
 static mrb_value
 vf_s_format_f(mrb_state *mrb, mrb_value klass)
@@ -167,7 +167,7 @@ mrb_init_test_vformat(mrb_state *mrb)
   
   VF_DEFINE_FORMAT_METHOD(c);
   VF_DEFINE_FORMAT_METHOD(d);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   VF_DEFINE_FORMAT_METHOD(f);
 #endif
   VF_DEFINE_FORMAT_METHOD(i);
diff --git a/mrbgems/mruby-time/src/time.c b/mrbgems/mruby-time/src/time.c
index 5fa700848..6fde1b2d1 100644
--- a/mrbgems/mruby-time/src/time.c
+++ b/mrbgems/mruby-time/src/time.c
@@ -4,7 +4,7 @@
 ** See Copyright Notice in mruby.h
 */
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #include <math.h>
 #endif
 
@@ -30,7 +30,7 @@ double round(double x) {
 }
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 # if !defined(__MINGW64__) && defined(_WIN32)
 #  define llround(x) round(x)
 # endif
@@ -199,13 +199,13 @@ struct mrb_time {
 
 static const struct mrb_data_type mrb_time_type = { "Time", mrb_free };
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 void mrb_check_num_exact(mrb_state *mrb, mrb_float num);
 typedef mrb_float mrb_sec;
 #define mrb_sec_value(mrb, sec) mrb_float_value(mrb, sec)
 #else
 typedef mrb_int mrb_sec;
-#define mrb_sec_value(mrb, sec) mrb_fixnum_value(sec)
+#define mrb_sec_value(mrb, sec) mrb_int_value(mrb, sec)
 #endif
 
 #define MRB_TIME_T_UINT (~(time_t)0 > 0)
@@ -218,11 +218,15 @@ typedef mrb_int mrb_sec;
                     (sizeof(time_t) <= 4 ? INT32_MAX : INT64_MAX)           \
 )
 
+/* return true if time_t is fit in mrb_int */
 static mrb_bool
 fixable_time_t_p(time_t v)
 {
   if (MRB_INT_MIN <= MRB_TIME_MIN && MRB_TIME_MAX <= MRB_INT_MAX) return TRUE;
-  return FIXABLE(v);
+  if (v > (time_t)MRB_INT_MAX) return FALSE;
+  if (MRB_TIME_T_UINT) return TRUE;
+  if (MRB_INT_MIN > (mrb_int)v) return FALSE;
+  return TRUE;
 }
 
 static time_t
@@ -231,7 +235,7 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec)
   time_t t;
 
   switch (mrb_type(obj)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     case MRB_TT_FLOAT:
       {
         mrb_float f = mrb_float(obj);
@@ -250,14 +254,14 @@ mrb_to_time_t(mrb_state *mrb, mrb_value obj, time_t *usec)
         }
       }
       break;
-#endif /* MRB_WITHOUT_FLOAT */
+#endif /* MRB_NO_FLOAT */
     default:
-    case MRB_TT_FIXNUM:
+    case MRB_TT_INTEGER:
       {
-        mrb_int i = mrb_int(mrb, obj);
+        mrb_int i = mrb_integer(obj);
 
-        if ((MRB_INT_MAX > MRB_TIME_MAX && i > 0 && i > (mrb_int)MRB_TIME_MAX) ||
-            (MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
+        if ((MRB_INT_MAX > MRB_TIME_MAX && i > 0 && (time_t)i > MRB_TIME_MAX) ||
+            (0 > MRB_TIME_MIN && MRB_TIME_MIN > MRB_INT_MIN && MRB_TIME_MIN > i)) {
           goto out_of_range;
         }
 
@@ -420,7 +424,7 @@ mrb_time_now(mrb_state *mrb, mrb_value self)
 MRB_API mrb_value
 mrb_time_at(mrb_state *mrb, time_t sec, time_t usec, enum mrb_timezone zone)
 {
-  return mrb_time_make_time(mrb, mrb_class_get(mrb, "Time"), sec, usec, zone);
+  return mrb_time_make_time(mrb, mrb_class_get_id(mrb, MRB_SYM(Time)), sec, usec, zone);
 }
 
 /* 15.2.19.6.1 */
@@ -572,7 +576,7 @@ mrb_time_minus(mrb_state *mrb, mrb_value self)
   tm = time_get_ptr(mrb, self);
   tm2 = DATA_CHECK_GET_PTR(mrb, other, &mrb_time_type, struct mrb_time);
   if (tm2) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     mrb_float f;
     f = (mrb_sec)(tm->sec - tm2->sec)
       + (mrb_sec)(tm->usec - tm2->usec) / 1.0e6;
@@ -581,7 +585,7 @@ mrb_time_minus(mrb_state *mrb, mrb_value self)
     mrb_int f;
     f = tm->sec - tm2->sec;
     if (tm->usec < tm2->usec) f--;
-    return mrb_fixnum_value(f);
+    return mrb_int_value(mrb, f);
 #endif
   }
   else {
@@ -843,7 +847,7 @@ mrb_time_sec(mrb_state *mrb, mrb_value self)
   return mrb_fixnum_value(tm->datetime.tm_sec);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /* 15.2.19.7.24 */
 /* Returns a Float with the time since the epoch in seconds. */
 static mrb_value
@@ -864,12 +868,12 @@ mrb_time_to_i(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm;
 
   tm = time_get_ptr(mrb, self);
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   if (!fixable_time_t_p(tm->sec)) {
     return mrb_float_value(mrb, (mrb_float)tm->sec);
   }
 #endif
-  return mrb_fixnum_value((mrb_int)tm->sec);
+  return mrb_int_value(mrb, (mrb_int)tm->sec);
 }
 
 /* 15.2.19.7.26 */
@@ -880,11 +884,6 @@ mrb_time_usec(mrb_state *mrb, mrb_value self)
   struct mrb_time *tm;
 
   tm = time_get_ptr(mrb, self);
-#ifndef MRB_WITHOUT_FLOAT
-  if (!fixable_time_t_p(tm->usec)) {
-    return mrb_float_value(mrb, (mrb_float)tm->usec);
-  }
-#endif
   return mrb_fixnum_value((mrb_int)tm->usec);
 }
 
@@ -995,7 +994,7 @@ mrb_mruby_time_gem_init(mrb_state* mrb)
 
   mrb_define_method(mrb, tc, "sec" , mrb_time_sec, MRB_ARGS_NONE());        /* 15.2.19.7.23 */
   mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, MRB_ARGS_NONE());       /* 15.2.19.7.25 */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, MRB_ARGS_NONE());       /* 15.2.19.7.24 */
 #endif
   mrb_define_method(mrb, tc, "usec", mrb_time_usec, MRB_ARGS_NONE());       /* 15.2.19.7.26 */
diff --git a/mrblib/10error.rb b/mrblib/10error.rb
index 0d9f38d58..054603514 100644
--- a/mrblib/10error.rb
+++ b/mrblib/10error.rb
@@ -21,6 +21,10 @@ end
 class TypeError < StandardError
 end
 
+# ISO 15.2.30
+class ZeroDivisionError < StandardError
+end
+
 # ISO 15.2.31
 class NameError < StandardError
   attr_accessor :name
diff --git a/mrblib/init_mrblib.c b/mrblib/init_mrblib.c
index 4d4bcd25a..e69de29bb 100644
--- a/mrblib/init_mrblib.c
+++ b/mrblib/init_mrblib.c
@@ -1,11 +0,0 @@
-#include <mruby.h>
-#include <mruby/irep.h>
-
-extern const uint8_t mrblib_irep[];
-
-void
-mrb_init_mrblib(mrb_state *mrb)
-{
-  mrb_load_irep(mrb, mrblib_irep);
-}
-
diff --git a/mrblib/mrblib.rake b/mrblib/mrblib.rake
index 6fba0adc1..724d328fa 100644
--- a/mrblib/mrblib.rake
+++ b/mrblib/mrblib.rake
@@ -11,8 +11,21 @@ MRuby.each_target do
     mkdir_p File.dirname(t.name)
     open(t.name, 'w') do |f|
       _pp "GEN", "*.rb", "#{t.name.relative_path}"
-      f.puts File.read("#{current_dir}/init_mrblib.c")
-      mrbc.run f, rbfiles, 'mrblib_irep'
+      f.puts %Q[/*]
+      f.puts %Q[ * This file is loading the mrblib]
+      f.puts %Q[ *]
+      f.puts %Q[ * IMPORTANT:]
+      f.puts %Q[ *   This file was generated!]
+      f.puts %Q[ *   All manual changes will get lost.]
+      f.puts %Q[ */]
+      mrbc.run f, rbfiles, 'mrblib_proc'
+      f.puts <<INIT_END
+void
+mrb_init_mrblib(mrb_state *mrb)
+{
+  mrb_load_proc(mrb, mrblib_proc);
+}
+INIT_END
     end
   end
 end
diff --git a/mrblib/numeric.rb b/mrblib/numeric.rb
index 5926518d5..e28d63324 100644
--- a/mrblib/numeric.rb
+++ b/mrblib/numeric.rb
@@ -34,11 +34,11 @@ class Numeric
 end
 
 ##
-# Integral
+# Integer
 #
-# mruby special - module to share methods between Floats and Integers
-#                 to make them compatible
-module Integral
+# ISO 15.2.8
+##
+class Integer
   ##
   # Calls the given block once for each Integer
   # from +self+ downto +num+.
@@ -125,14 +125,7 @@ module Integral
     end
     self
   end
-end
 
-##
-# Integer
-#
-# ISO 15.2.8
-class Integer
-  include Integral
   ##
   # Returns the receiver simply.
   #
@@ -161,3 +154,35 @@ class Integer
   # ISO 15.2.8.3.26
   alias truncate floor
 end
+
+class Float
+  ##
+  # Calls the given block from +self+ to +num+
+  # incremented by +step+ (default 1).
+  #
+  def step(num=nil, step=1, &block)
+    raise ArgumentError, "step can't be 0" if step == 0
+    return to_enum(:step, num, step) unless block
+
+    i = self
+    if num == self || step.infinite?
+      block.call(i) if step > 0 && i <= (num||i) || step < 0 && i >= (num||-i)
+    elsif num == nil
+      while true
+        block.call(i)
+        i += step
+      end
+    elsif step > 0
+      while i <= num
+        block.call(i)
+        i += step
+      end
+    else
+      while i >= num
+        block.call(i)
+        i += step
+      end
+    end
+    self
+  end
+end
diff --git a/mrblib/range.rb b/mrblib/range.rb
index 392cc2274..9f94f35d1 100644
--- a/mrblib/range.rb
+++ b/mrblib/range.rb
@@ -15,7 +15,7 @@ class Range
     val = self.first
     last = self.last
 
-    if val.kind_of?(Fixnum) && last.kind_of?(Fixnum) # fixnums are special
+    if val.kind_of?(Integer) && last.kind_of?(Integer) # fixnums are special
       lim = last
       lim += 1 unless exclude_end?
       i = val
diff --git a/src/array.c b/src/array.c
index c33641264..c4bc554ef 100644
--- a/src/array.c
+++ b/src/array.c
@@ -508,21 +508,23 @@ mrb_ary_push(mrb_state *mrb, mrb_value ary, mrb_value elem)
 static mrb_value
 mrb_ary_push_m(mrb_state *mrb, mrb_value self)
 {
+  mrb_int argc;
   mrb_value *argv;
-  mrb_int len, len2, alen;
+  mrb_int len, len2;
   struct RArray *a;
 
-  mrb_get_args(mrb, "*!", &argv, &alen);
+  argc = mrb_get_argc(mrb);
+  argv = mrb_get_argv(mrb);
   a = mrb_ary_ptr(self);
   ary_modify(mrb, a);
   len = ARY_LEN(a);
-  len2 = len + alen;
+  len2 = len + argc;
   if (ARY_CAPA(a) < len2) {
     ary_expand_capa(mrb, a, len2);
   }
-  array_copy(ARY_PTR(a)+len, argv, alen);
+  array_copy(ARY_PTR(a)+len, argv, argc);
   ARY_SET_LEN(a, len2);
-  while (alen--) {
+  while (argc--) {
     mrb_field_write_barrier_value(mrb, (struct RBasic*)a, *argv);
     argv++;
   }
@@ -820,10 +822,10 @@ mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len)
 static mrb_int
 aget_index(mrb_state *mrb, mrb_value index)
 {
-  if (mrb_fixnum_p(index)) {
-    return mrb_fixnum(index);
+  if (mrb_integer_p(index)) {
+    return mrb_integer(index);
   }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   else if (mrb_float_p(index)) {
     return (mrb_int)mrb_float(index);
   }
@@ -883,8 +885,8 @@ mrb_ary_aget(mrb_state *mrb, mrb_value self)
       else {
         return mrb_nil_value();
       }
-    case MRB_TT_FIXNUM:
-      return mrb_ary_ref(mrb, self, mrb_fixnum(index));
+    case MRB_TT_INTEGER:
+      return mrb_ary_ref(mrb, self, mrb_integer(index));
     default:
       return mrb_ary_ref(mrb, self, aget_index(mrb, index));
     }
@@ -1086,11 +1088,11 @@ mrb_ary_splat(mrb_state *mrb, mrb_value v)
     return mrb_obj_value(a);
   }
 
-  if (!mrb_respond_to(mrb, v, mrb_intern_lit(mrb, "to_a"))) {
+  if (!mrb_respond_to(mrb, v, MRB_SYM(to_a))) {
     return mrb_ary_new_from_values(mrb, 1, &v);
   }
 
-  ary = mrb_funcall(mrb, v, "to_a", 0);
+  ary = mrb_funcall_id(mrb, v, MRB_SYM(to_a), 0);
   if (mrb_nil_p(ary)) {
     return mrb_ary_new_from_values(mrb, 1, &v);
   }
@@ -1121,8 +1123,14 @@ mrb_ary_clear(mrb_state *mrb, mrb_value self)
   else if (!ARY_EMBED_P(a)){
     mrb_free(mrb, a->as.heap.ptr);
   }
-  ARY_SET_EMBED_LEN(a, 0);
-
+  if (MRB_ARY_EMBED_LEN_MAX > 0) {
+    ARY_SET_EMBED_LEN(a, 0);
+  }
+  else {
+    a->as.heap.ptr = NULL;
+    a->as.heap.aux.capa = 0;
+    ARY_SET_LEN(a, 0);
+  }
   return self;
 }
 
@@ -1302,31 +1310,42 @@ static const mrb_code each_iseq[] = {
   OP_RETURN, 0x0             /* OP_RETURN    R3 */
 };
 
+static const mrb_sym each_syms[] = {
+  MRB_SYM(each),
+  MRB_SYM(to_enum),
+  MRB_QSYM(aref),
+  MRB_SYM(call),
+  MRB_SYM(length),
+};
+
+static const mrb_irep each_irep = {
+  3,                                   /* nlocals */
+  7,                                   /* nregs */
+  0,                                   /* clen */
+  MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE, /* flags */
+  each_iseq,                           /* iseq */
+  NULL,                                /* pool */
+  each_syms,                           /* syms */
+  NULL,                                /* reps */
+  NULL,                                /* lv */
+  NULL,                                /* debug_info */
+  sizeof(each_iseq),                   /* ilen */
+  0,                                   /* plen */
+  sizeof(each_syms),                   /* slen */
+  1,                                   /* rlen */
+  0,                                   /* refcnt */
+};
+
 static void
 init_ary_each(mrb_state *mrb, struct RClass *ary)
 {
   struct RProc *p;
   mrb_method_t m;
-  mrb_irep *each_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
-  static const mrb_irep mrb_irep_zero = { 0 };
-
-  *each_irep = mrb_irep_zero;
-  each_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*5);
-  each_irep->syms[0] = mrb_intern_lit(mrb, "each");
-  each_irep->syms[1] = mrb_intern_lit(mrb, "to_enum");
-  each_irep->syms[2] = mrb_intern_lit(mrb, "[]");
-  each_irep->syms[3] = mrb_intern_lit(mrb, "call");
-  each_irep->syms[4] = mrb_intern_lit(mrb, "length");
-  each_irep->slen = 5;
-  each_irep->flags = MRB_ISEQ_NO_FREE;
-  each_irep->iseq = each_iseq;
-  each_irep->ilen = sizeof(each_iseq);
-  each_irep->nregs = 7;
-  each_irep->nlocals = 3;
-  p = mrb_proc_new(mrb, each_irep);
+
+  p = mrb_proc_new(mrb, &each_irep);
   p->flags |= MRB_PROC_SCOPE | MRB_PROC_STRICT;
   MRB_METHOD_FROM_PROC(m, p);
-  mrb_define_method_raw(mrb, ary, mrb_intern_lit(mrb, "each"), m);
+  mrb_define_method_raw(mrb, ary, MRB_SYM(each), m);
 }
 
 void
diff --git a/src/backtrace.c b/src/backtrace.c
index 591f4ea4b..bcc188796 100644
--- a/src/backtrace.c
+++ b/src/backtrace.c
@@ -39,7 +39,7 @@ each_backtrace(mrb_state *mrb, ptrdiff_t ciidx, const mrb_code *pc0, each_backtr
   for (i=ciidx; i >= 0; i--) {
     struct backtrace_location loc;
     mrb_callinfo *ci;
-    mrb_irep *irep;
+    const mrb_irep *irep;
     const mrb_code *pc;
 
     ci = &mrb->c->cibase[i];
@@ -114,7 +114,7 @@ mrb_print_backtrace(mrb_state *mrb)
     return;
   }
 
-  backtrace = mrb_obj_iv_get(mrb, mrb->exc, mrb_intern_lit(mrb, "backtrace"));
+  backtrace = mrb_obj_iv_get(mrb, mrb->exc, MRB_SYM(backtrace));
   if (mrb_nil_p(backtrace)) return;
   if (!mrb_array_p(backtrace)) backtrace = mrb_unpack_backtrace(mrb, backtrace);
   print_backtrace(mrb, mrb->exc, backtrace);
@@ -171,7 +171,7 @@ packed_backtrace(mrb_state *mrb)
 void
 mrb_keep_backtrace(mrb_state *mrb, mrb_value exc)
 {
-  mrb_sym sym = mrb_intern_lit(mrb, "backtrace");
+  mrb_sym sym = MRB_SYM(backtrace);
   mrb_value backtrace;
   int ai;
 
@@ -221,7 +221,7 @@ mrb_exc_backtrace(mrb_state *mrb, mrb_value exc)
   mrb_sym attr_name;
   mrb_value backtrace;
 
-  attr_name = mrb_intern_lit(mrb, "backtrace");
+  attr_name = MRB_SYM(backtrace);
   backtrace = mrb_iv_get(mrb, exc, attr_name);
   if (mrb_nil_p(backtrace) || mrb_array_p(backtrace)) {
     return backtrace;
diff --git a/src/class.c b/src/class.c
index fcbdadea8..bbf64e8ea 100644
--- a/src/class.c
+++ b/src/class.c
@@ -18,47 +18,266 @@
 #include <mruby/istruct.h>
 #include <mruby/opcode.h>
 
-KHASH_DEFINE(mt, mrb_sym, mrb_method_t, TRUE, kh_int_hash_func, kh_int_hash_equal)
+union mt_ptr {
+  struct RProc *proc;
+  mrb_func_t func;
+};
+
+struct mt_elem {
+  union mt_ptr ptr;
+  size_t func_p:1;
+  mrb_sym key:sizeof(mrb_sym)*8-1;
+};
+
+/* method table structure */
+typedef struct mt_tbl {
+  size_t size;
+  size_t alloc;
+  struct mt_elem *table;
+} mt_tbl;
+
+/* Creates the method table. */
+static mt_tbl*
+mt_new(mrb_state *mrb)
+{
+  mt_tbl *t;
+
+  t = (mt_tbl*)mrb_malloc(mrb, sizeof(mt_tbl));
+  t->size = 0;
+  t->alloc = 0;
+  t->table = NULL;
+
+  return t;
+}
+
+static struct mt_elem *mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, size_t func_p, union mt_ptr ptr);
+
+static void
+mt_rehash(mrb_state *mrb, mt_tbl *t)
+{
+  size_t old_alloc = t->alloc;
+  size_t new_alloc = old_alloc+1;
+  struct mt_elem *old_table = t->table;
+
+  khash_power2(new_alloc);
+  if (old_alloc == new_alloc) return;
+
+  t->alloc = new_alloc;
+  t->size = 0;
+  t->table = (struct mt_elem*)mrb_calloc(mrb, sizeof(struct mt_elem), new_alloc);
+
+  for (size_t i = 0; i < old_alloc; i++) {
+    struct mt_elem *slot = &old_table[i];
+
+    /* key = 0 means empty or deleted */
+    if (slot->key != 0) {
+      mt_put(mrb, t, slot->key, slot->func_p, slot->ptr);
+    }
+  }
+  mrb_free(mrb, old_table);
+}
+
+#define slot_empty_p(slot) ((slot)->key == 0 && (slot)->func_p == 0)
+
+/* Set the value for the symbol in the method table. */
+static struct mt_elem*
+mt_put(mrb_state *mrb, mt_tbl *t, mrb_sym sym, size_t func_p, union mt_ptr ptr)
+{
+  size_t hash, pos, start;
+  struct mt_elem *dslot = NULL;
+
+  if (t->alloc == 0) {
+    mt_rehash(mrb, t);
+  }
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct mt_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      slot->func_p = func_p;
+      slot->ptr = ptr;
+      return slot;
+    }
+    else if (slot->key == 0) {  /* empty or deleted */
+      if (slot->func_p == 0) {  /* empty */
+        t->size++;
+        slot->key = sym;
+        slot->func_p = func_p;
+        slot->ptr = ptr;
+        return slot;
+      }
+      else if (!dslot) {        /* deleted */
+        dslot = slot;
+      }
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      if (dslot) {
+        t->size++;
+        dslot->key = sym;
+        dslot->func_p = func_p;
+        dslot->ptr = ptr;
+        return dslot;
+      }
+      /* no room */
+      mt_rehash(mrb, t);
+      start = pos = hash & (t->alloc-1);
+    }
+  }
+}
+
+/* Get a value for a symbol from the method table. */
+static struct mt_elem*
+mt_get(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
+{
+  size_t hash, pos, start;
+
+  if (t == NULL) return NULL;
+  if (t->alloc == 0) return NULL;
+  if (t->size == 0) return NULL;
+
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct mt_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      return slot;
+    }
+    else if (slot_empty_p(slot)) {
+      return NULL;
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      return NULL;
+    }
+  }
+}
+
+/* Deletes the value for the symbol from the method table. */
+static mrb_bool
+mt_del(mrb_state *mrb, mt_tbl *t, mrb_sym sym)
+{
+  size_t hash, pos, start;
+
+  if (t == NULL) return FALSE;
+  if (t->alloc == 0) return  FALSE;
+  if (t->size == 0) return FALSE;
+
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct mt_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      t->size--;
+      slot->key = 0;
+      slot->func_p = 1;
+      return TRUE;
+    }
+    else if (slot_empty_p(slot)) {
+      return FALSE;
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      return FALSE;
+    }
+  }
+}
+
+/* Copy the method table. */
+static struct mt_tbl*
+mt_copy(mrb_state *mrb, mt_tbl *t)
+{
+  mt_tbl *t2;
+  size_t i;
+
+  if (t == NULL) return NULL;
+  if (t->alloc == 0) return NULL;
+  if (t->size == 0) return NULL;
+
+  t2 = mt_new(mrb);
+  for (i=0; i<t->alloc; i++) {
+    struct mt_elem *slot = &t->table[i];
+
+    if (slot->key) {
+      mt_put(mrb, t2, slot->key, slot->func_p, slot->ptr);
+    }
+  }
+  return t2;
+}
+
+/* Free memory of the method table. */
+static void
+mt_free(mrb_state *mrb, mt_tbl *t)
+{
+  mrb_free(mrb, t->table);
+  mrb_free(mrb, t);
+}
+
+MRB_API void
+mrb_mt_foreach(mrb_state *mrb, struct RClass *c, mrb_mt_foreach_func *fn, void *p)
+{
+  mt_tbl *t = c->mt;
+  size_t i;
+
+  if (t == NULL) return;
+  if (t->alloc == 0) return;
+  if (t->size == 0) return;
+
+  for (i=0; i<t->alloc; i++) {
+    struct mt_elem *slot = &t->table[i];
+
+    if (slot->key) {
+      if (fn(mrb, slot->key, slot, p) != 0)
+        return;
+    }
+  }
+  return;
+}
 
 void
 mrb_gc_mark_mt(mrb_state *mrb, struct RClass *c)
 {
-  khiter_t k;
-  khash_t(mt) *h = c->mt;
+  mt_tbl *t = c->mt;
+  size_t i;
 
-  if (!h) return;
-  for (k = kh_begin(h); k != kh_end(h); k++) {
-    if (kh_exist(h, k)) {
-      mrb_method_t m = kh_value(h, k);
+  if (t == NULL) return;
+  if (t->alloc == 0) return;
+  if (t->size == 0) return;
 
-      if (MRB_METHOD_PROC_P(m)) {
-        struct RProc *p = MRB_METHOD_PROC(m);
-        mrb_gc_mark(mrb, (struct RBasic*)p);
-      }
+  for (i=0; i<t->alloc; i++) {
+    struct mt_elem *slot = &t->table[i];
+
+    if (slot->key && !slot->func_p) { /* Proc pointer */
+      struct RProc *p = slot->ptr.proc;
+      mrb_gc_mark(mrb, (struct RBasic*)p);
     }
   }
+  return;
 }
 
 size_t
 mrb_gc_mark_mt_size(mrb_state *mrb, struct RClass *c)
 {
-  khash_t(mt) *h = c->mt;
+  struct mt_tbl *h = c->mt;
 
   if (!h) return 0;
-  return kh_size(h);
+  return h->size;
 }
 
 void
 mrb_gc_free_mt(mrb_state *mrb, struct RClass *c)
 {
-  kh_destroy(mt, mrb, c->mt);
+  if (c->mt) mt_free(mrb, c->mt);
 }
 
 void
 mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb_sym id)
 {
   mrb_value name;
-  mrb_sym nsym = mrb_intern_lit(mrb, "__classname__");
+  mrb_sym nsym = MRB_SYM(__classname__);
 
   if (mrb_obj_iv_defined(mrb, (struct RObject*)c, nsym)) return;
   if (outer == NULL || outer == mrb->object_class) {
@@ -68,7 +287,7 @@ mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb
     name = mrb_class_path(mrb, outer);
     if (mrb_nil_p(name)) {      /* unnamed outer class */
       if (outer != mrb->object_class && outer != c) {
-        mrb_obj_iv_set_force(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"),
+        mrb_obj_iv_set_force(mrb, (struct RObject*)c, MRB_SYM(__outer__),
                              mrb_obj_value(outer));
       }
       return;
@@ -107,7 +326,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o)
   if (o->c->tt == MRB_TT_SCLASS) return;
   sc = (struct RClass*)mrb_obj_alloc(mrb, MRB_TT_SCLASS, mrb->class_class);
   sc->flags |= MRB_FL_CLASS_IS_INHERITED;
-  sc->mt = kh_init(mt, mrb);
+  sc->mt = mt_new(mrb);
   sc->iv = 0;
   if (o->tt == MRB_TT_CLASS) {
     c = (struct RClass*)o;
@@ -132,7 +351,7 @@ prepare_singleton_class(mrb_state *mrb, struct RBasic *o)
   o->c = sc;
   mrb_field_write_barrier(mrb, (struct RBasic*)o, (struct RBasic*)sc);
   mrb_field_write_barrier(mrb, (struct RBasic*)sc, (struct RBasic*)o);
-  mrb_obj_iv_set(mrb, (struct RObject*)sc, mrb_intern_lit(mrb, "__attached__"), mrb_obj_value(o));
+  mrb_obj_iv_set(mrb, (struct RObject*)sc, MRB_SYM(__attached__), mrb_obj_value(o));
   sc->flags |= o->flags & MRB_FL_OBJ_IS_FROZEN;
 }
 
@@ -230,6 +449,15 @@ mrb_vm_define_module(mrb_state *mrb, mrb_value outer, mrb_sym id)
 }
 
 MRB_API struct RClass*
+mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name)
+{
+  struct RClass * c = define_module(mrb, name, outer);
+
+  setup_class(mrb, outer, c, name);
+  return c;
+}
+
+MRB_API struct RClass*
 mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name)
 {
   mrb_sym id = mrb_intern_cstr(mrb, name);
@@ -283,12 +511,10 @@ mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super)
 }
 
 static mrb_value mrb_bob_init(mrb_state *mrb, mrb_value);
-#ifdef MRB_METHOD_CACHE
-static void mc_clear_all(mrb_state *mrb);
-static void mc_clear_by_id(mrb_state *mrb, struct RClass*, mrb_sym);
+#ifndef MRB_NO_METHOD_CACHE
+static void mc_clear(mrb_state *mrb);
 #else
-#define mc_clear_all(mrb)
-#define mc_clear_by_id(mrb,c,s)
+#define mc_clear(mrb)
 #endif
 
 static void
@@ -302,7 +528,7 @@ mrb_class_inherited(mrb_state *mrb, struct RClass *super, struct RClass *klass)
   super->flags |= MRB_FL_CLASS_IS_INHERITED;
   s = mrb_obj_value(super);
   mrb_mc_clear_by_class(mrb, klass);
-  mid = mrb_intern_lit(mrb, "inherited");
+  mid = MRB_SYM(inherited);
   if (!mrb_func_basic_p(mrb, s, mid, mrb_bob_init)) {
     mrb_value c = mrb_obj_value(klass);
     mrb_funcall_argv(mrb, s, mid, 1, &c);
@@ -349,21 +575,29 @@ mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id
 MRB_API mrb_bool
 mrb_class_defined(mrb_state *mrb, const char *name)
 {
-  mrb_value sym = mrb_check_intern_cstr(mrb, name);
-  if (mrb_nil_p(sym)) {
-    return FALSE;
-  }
-  return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), mrb_symbol(sym));
+  mrb_sym sym = mrb_intern_check_cstr(mrb, name);
+  if (!sym) return FALSE;
+  return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), sym);
+}
+
+MRB_API mrb_bool
+mrb_class_defined_id(mrb_state *mrb, mrb_sym name)
+{
+  return mrb_const_defined(mrb, mrb_obj_value(mrb->object_class), name);
 }
 
 MRB_API mrb_bool
 mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name)
 {
-  mrb_value sym = mrb_check_intern_cstr(mrb, name);
-  if (mrb_nil_p(sym)) {
-    return FALSE;
-  }
-  return mrb_const_defined_at(mrb, mrb_obj_value(outer), mrb_symbol(sym));
+  mrb_sym sym = mrb_intern_check_cstr(mrb, name);
+  if (!sym) return FALSE;
+  return mrb_const_defined_at(mrb, mrb_obj_value(outer), sym);
+}
+
+MRB_API mrb_bool
+mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name)
+{
+  return mrb_const_defined_at(mrb, mrb_obj_value(outer), name);
 }
 
 MRB_API struct RClass*
@@ -373,17 +607,28 @@ mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
 }
 
 MRB_API struct RClass*
+mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name)
+{
+  return class_from_sym(mrb, outer, name);
+}
+
+MRB_API struct RClass*
 mrb_class_get(mrb_state *mrb, const char *name)
 {
   return mrb_class_get_under(mrb, mrb->object_class, name);
 }
 
 MRB_API struct RClass*
-mrb_exc_get(mrb_state *mrb, const char *name)
+mrb_class_get_id(mrb_state *mrb, mrb_sym name)
+{
+  return mrb_class_get_under_id(mrb, mrb->object_class, name);
+}
+
+MRB_API struct RClass*
+mrb_exc_get_id(mrb_state *mrb, mrb_sym name)
 {
   struct RClass *exc, *e;
-  mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class),
-                              mrb_intern_cstr(mrb, name));
+  mrb_value c = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), name);
 
   if (!mrb_class_p(c)) {
     mrb_raise(mrb, mrb->eException_class, "exception corrupted");
@@ -405,11 +650,23 @@ mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name)
 }
 
 MRB_API struct RClass*
+mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name)
+{
+  return module_from_sym(mrb, outer, name);
+}
+
+MRB_API struct RClass*
 mrb_module_get(mrb_state *mrb, const char *name)
 {
   return mrb_module_get_under(mrb, mrb->object_class, name);
 }
 
+MRB_API struct RClass*
+mrb_module_get_id(mrb_state *mrb, mrb_sym name)
+{
+  return mrb_module_get_under_id(mrb, mrb->object_class, name);
+}
+
 /*!
  * Defines a class under the namespace of \a outer.
  * \param outer  a class which contains the new class.
@@ -427,9 +684,8 @@ mrb_module_get(mrb_state *mrb, const char *name)
  *       \a super, the function just returns the defined class.
  */
 MRB_API struct RClass*
-mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
+mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super)
 {
-  mrb_sym id = mrb_intern_cstr(mrb, name);
   struct RClass * c;
 
 #if 0
@@ -437,34 +693,45 @@ mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, s
     mrb_warn(mrb, "no super class for '%C::%n', Object assumed", outer, id);
   }
 #endif
-  c = define_class(mrb, id, super, outer);
-  setup_class(mrb, outer, c, id);
+  c = define_class(mrb, name, super, outer);
+  setup_class(mrb, outer, c, name);
   return c;
 }
 
+MRB_API struct RClass*
+mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super)
+{
+  return mrb_define_class_under_id(mrb, outer, mrb_intern_cstr(mrb, name), super);
+}
+
 MRB_API void
 mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_t m)
 {
-  khash_t(mt) *h;
-  khiter_t k;
+  mt_tbl *h;
+  union mt_ptr ptr;
+
   MRB_CLASS_ORIGIN(c);
   h = c->mt;
-
   mrb_check_frozen(mrb, c);
-  if (!h) h = c->mt = kh_init(mt, mrb);
-  k = kh_put(mt, mrb, h, mid);
-  kh_value(h, k) = m;
-  if (MRB_METHOD_PROC_P(m) && !MRB_METHOD_UNDEF_P(m)) {
+  if (!h) h = c->mt = mt_new(mrb);
+  if (MRB_METHOD_PROC_P(m)) {
     struct RProc *p = MRB_METHOD_PROC(m);
 
-    p->flags |= MRB_PROC_SCOPE;
-    p->c = NULL;
-    mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p);
-    if (!MRB_PROC_ENV_P(p)) {
-      MRB_PROC_SET_TARGET_CLASS(p, c);
+    ptr.proc = p;
+    if (p) {
+      p->flags |= MRB_PROC_SCOPE;
+      p->c = NULL;
+      mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)p);
+      if (!MRB_PROC_ENV_P(p)) {
+        MRB_PROC_SET_TARGET_CLASS(p, c);
+      }
     }
   }
-  mc_clear_by_id(mrb, c, mid);
+  else {
+    ptr.func = MRB_METHOD_FUNC(m);
+  }
+  mt_put(mrb, h, mid, MRB_METHOD_FUNC_P(m), ptr);
+  mc_clear(mrb);
 }
 
 MRB_API void
@@ -474,6 +741,9 @@ mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t f
   int ai = mrb_gc_arena_save(mrb);
 
   MRB_METHOD_FROM_FUNC(m, func);
+#ifndef MRB_USE_METHOD_T_STRUCT
+  mrb_assert(MRB_METHOD_FUNC(m) == func);
+#endif
   if (aspec == MRB_ARGS_NONE()) {
     MRB_METHOD_NOARG_SET(m);
   }
@@ -588,8 +858,8 @@ void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self);
     z:      String         [const char*]          NUL terminated string; z! gives NULL for nil
     a:      Array          [mrb_value*,mrb_int]   Receive two arguments; a! gives (NULL,0) for nil
     c:      Class/Module   [strcut RClass*]
-    f:      Fixnum/Float   [mrb_float]
-    i:      Fixnum/Float   [mrb_int]
+    f:      Integer/Float  [mrb_float]
+    i:      Integer/Float  [mrb_int]
     b:      boolean        [mrb_bool]
     n:      String/Symbol  [mrb_sym]
     d:      data           [void*,mrb_data_type const] 2nd argument will be used to check data type so it won't be modified; when ! follows, the value may be nil
@@ -849,7 +1119,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         }
       }
       break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     case 'f':
       {
         mrb_float *p;
@@ -867,7 +1137,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
 
         p = va_arg(ap, mrb_int*);
         if (i < argc) {
-          *p = mrb_fixnum(mrb_to_int(mrb, argv[i++]));
+          *p = mrb_integer(mrb_to_int(mrb, argv[i++]));
         }
       }
       break;
@@ -984,7 +1254,7 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
         else {
           uint32_t kwnum = kwargs->num;
           uint32_t required = kwargs->required;
-          const char *const *kname = kwargs->table;
+          const mrb_sym *kname = kwargs->table;
           mrb_value *values = kwargs->values;
           uint32_t j;
           const uint32_t keyword_max = 40;
@@ -994,16 +1264,16 @@ mrb_get_args(mrb_state *mrb, const char *format, ...)
           }
 
           for (j = required; j > 0; j --, kname ++, values ++) {
-            mrb_value k = mrb_symbol_value(mrb_intern_cstr(mrb, *kname));
+            mrb_value k = mrb_symbol_value(*kname);
             if (!mrb_hash_key_p(mrb, ksrc, k)) {
-              mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %s", *kname);
+              mrb_raisef(mrb, E_ARGUMENT_ERROR, "missing keyword: %n", *kname);
             }
             *values = mrb_hash_delete_key(mrb, ksrc, k);
             mrb_gc_protect(mrb, *values);
           }
 
           for (j = kwnum - required; j > 0; j --, kname ++, values ++) {
-            mrb_value k = mrb_symbol_value(mrb_intern_cstr(mrb, *kname));
+            mrb_value k = mrb_symbol_value(*kname);
             if (mrb_hash_key_p(mrb, ksrc, k)) {
               *values = mrb_hash_delete_key(mrb, ksrc, k);
               mrb_gc_protect(mrb, *values);
@@ -1057,7 +1327,7 @@ boot_defclass(mrb_state *mrb, struct RClass *super)
   else {
     c->super = mrb->object_class;
   }
-  c->mt = kh_init(mt, mrb);
+  c->mt = mt_new(mrb);
   return c;
 }
 
@@ -1065,7 +1335,7 @@ static void
 boot_initmod(mrb_state *mrb, struct RClass *mod)
 {
   if (!mod->mt) {
-    mod->mt = kh_init(mt, mrb);
+    mod->mt = mt_new(mrb);
   }
 }
 
@@ -1129,7 +1399,7 @@ include_module_at(mrb_state *mrb, struct RClass *c, struct RClass *ins_pos, stru
   skip:
     m = m->super;
   }
-  mc_clear_all(mrb);
+  mc_clear(mrb);
   return 0;
 }
 
@@ -1155,7 +1425,7 @@ mrb_prepend_module(mrb_state *mrb, struct RClass *c, struct RClass *m)
     origin->super = c->super;
     c->super = origin;
     origin->mt = c->mt;
-    c->mt = kh_init(mt, mrb);
+    c->mt = mt_new(mrb);
     mrb_field_write_barrier(mrb, (struct RBasic*)c, (struct RBasic*)origin);
     c->flags |= MRB_FL_CLASS_IS_PREPENDED;
   }
@@ -1292,8 +1562,8 @@ mrb_singleton_class_ptr(mrb_state *mrb, mrb_value v)
   case MRB_TT_CPTR:
     return mrb->object_class;
   case MRB_TT_SYMBOL:
-  case MRB_TT_FIXNUM:
-#ifndef MRB_WITHOUT_FLOAT
+  case MRB_TT_INTEGER:
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
 #endif
     return NULL;
@@ -1324,28 +1594,42 @@ mrb_define_singleton_method(mrb_state *mrb, struct RObject *o, const char *name,
 }
 
 MRB_API void
+mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *o, mrb_sym name, mrb_func_t func, mrb_aspec aspec)
+{
+  prepare_singleton_class(mrb, (struct RBasic*)o);
+  mrb_define_method_id(mrb, o->c, name, func, aspec);
+}
+
+MRB_API void
 mrb_define_class_method(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
 {
   mrb_define_singleton_method(mrb, (struct RObject*)c, name, func, aspec);
 }
 
 MRB_API void
+mrb_define_class_method_id(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_func_t func, mrb_aspec aspec)
+{
+  mrb_define_singleton_method_id(mrb, (struct RObject*)c, name, func, aspec);
+}
+
+MRB_API void
+mrb_define_module_function_id(mrb_state *mrb, struct RClass *c, mrb_sym name, mrb_func_t func, mrb_aspec aspec)
+{
+  mrb_define_class_method_id(mrb, c, name, func, aspec);
+  mrb_define_method_id(mrb, c, name, func, aspec);
+}
+
+MRB_API void
 mrb_define_module_function(mrb_state *mrb, struct RClass *c, const char *name, mrb_func_t func, mrb_aspec aspec)
 {
-  mrb_define_class_method(mrb, c, name, func, aspec);
-  mrb_define_method(mrb, c, name, func, aspec);
+  mrb_define_module_function_id(mrb, c, mrb_intern_cstr(mrb, name), func, aspec);
 }
 
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
 static void
-mc_clear_all(mrb_state *mrb)
+mc_clear(mrb_state *mrb)
 {
-  struct mrb_cache_entry *mc = mrb->cache;
-  int i;
-
-  for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) {
-    mc[i].c = 0;
-  }
+  memset(mrb->cache, 0, MRB_METHOD_CACHE_SIZE*sizeof(mrb->cache[0]));
 }
 
 void
@@ -1355,7 +1639,7 @@ mrb_mc_clear_by_class(mrb_state *mrb, struct RClass *c)
   int i;
 
   if (c->flags & MRB_FL_CLASS_IS_INHERITED) {
-    mc_clear_all(mrb);
+    mc_clear(mrb);
     c->flags &= ~MRB_FL_CLASS_IS_INHERITED;
     return;
   }
@@ -1363,32 +1647,14 @@ mrb_mc_clear_by_class(mrb_state *mrb, struct RClass *c)
     if (mc[i].c == c) mc[i].c = 0;
   }
 }
-
-static void
-mc_clear_by_id(mrb_state *mrb, struct RClass *c, mrb_sym mid)
-{
-  struct mrb_cache_entry *mc = mrb->cache;
-  int i;
-
-  if (c->flags & MRB_FL_CLASS_IS_INHERITED) {
-    mc_clear_all(mrb);
-    c->flags &= ~MRB_FL_CLASS_IS_INHERITED;
-    return;
-  }
-  for (i=0; i<MRB_METHOD_CACHE_SIZE; i++) {
-    if (mc[i].c == c || mc[i].mid == mid)
-      mc[i].c = 0;
-  }
-}
 #endif
 
 MRB_API mrb_method_t
 mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
 {
-  khiter_t k;
   mrb_method_t m;
   struct RClass *c = *cp;
-#ifdef MRB_METHOD_CACHE
+#ifndef MRB_NO_METHOD_CACHE
   struct RClass *oc = c;
   int h = kh_int_hash_func(mrb, ((intptr_t)oc) ^ mid) & (MRB_METHOD_CACHE_SIZE-1);
   struct mrb_cache_entry *mc = &mrb->cache[h];
@@ -1400,15 +1666,20 @@ mrb_method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
 #endif
 
   while (c) {
-    khash_t(mt) *h = c->mt;
+    mt_tbl *h = c->mt;
 
     if (h) {
-      k = kh_get(mt, mrb, h, mid);
-      if (k != kh_end(h)) {
-        m = kh_value(h, k);
-        if (MRB_METHOD_UNDEF_P(m)) break;
+      struct mt_elem *e = mt_get(mrb, h, mid);
+      if (e) {
+        if (e->ptr.proc == 0) break;
         *cp = c;
-#ifdef MRB_METHOD_CACHE
+        if (e->func_p) {
+          MRB_METHOD_FROM_FUNC(m, e->ptr.func);
+        }
+        else {
+          MRB_METHOD_FROM_PROC(m, e->ptr.proc);
+        }
+#ifndef MRB_NO_METHOD_CACHE
         mc->c = oc;
         mc->c0 = c;
         mc->mid = mid;
@@ -1578,7 +1849,7 @@ mrb_instance_new(mrb_state *mrb, mrb_value cv)
 
   mrb_get_args(mrb, "*!&", &argv, &argc, &blk);
   obj = mrb_instance_alloc(mrb, cv);
-  init = mrb_intern_lit(mrb, "initialize");
+  init = MRB_SYM(initialize);
   if (!mrb_func_basic_p(mrb, obj, init, mrb_bob_init)) {
     mrb_funcall_with_block(mrb, obj, init, argc, argv, blk);
   }
@@ -1592,7 +1863,7 @@ mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *arg
   mrb_sym mid;
 
   obj = mrb_instance_alloc(mrb, mrb_obj_value(c));
-  mid = mrb_intern_lit(mrb, "initialize");
+  mid = MRB_SYM(initialize);
   if (!mrb_func_basic_p(mrb, obj, mid, mrb_bob_init)) {
     mrb_funcall_argv(mrb, obj, mid, argc, argv);
   }
@@ -1624,7 +1895,7 @@ mrb_class_new_class(mrb_state *mrb, mrb_value cv)
     super = mrb_obj_value(mrb->object_class);
   }
   new_class = mrb_obj_value(mrb_class_new(mrb, mrb_class_ptr(super)));
-  mid = mrb_intern_lit(mrb, "initialize");
+  mid = MRB_SYM(initialize);
   if (mrb_func_basic_p(mrb, new_class, mid, mrb_class_initialize)) {
     mrb_class_initialize(mrb, new_class);
   }
@@ -1722,7 +1993,7 @@ MRB_API mrb_value
 mrb_class_path(mrb_state *mrb, struct RClass *c)
 {
   mrb_value path;
-  mrb_sym nsym = mrb_intern_lit(mrb, "__classname__");
+  mrb_sym nsym = MRB_SYM(__classname__);
 
   path = mrb_obj_iv_get(mrb, (struct RObject*)c, nsym);
   if (mrb_nil_p(path)) {
@@ -1827,7 +2098,7 @@ mrb_module_new(mrb_state *mrb)
  *  called with an explicit receiver, as <code>class</code> is also a
  *  reserved word in Ruby.
  *
- *     1.class      #=> Fixnum
+ *     1.class      #=> Integer
  *     self.class   #=> Object
  */
 
@@ -1877,6 +2148,12 @@ mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const
   mrb_alias_method(mrb, klass, mrb_intern_cstr(mrb, name1), mrb_intern_cstr(mrb, name2));
 }
 
+MRB_API void
+mrb_define_alias_id(mrb_state *mrb, struct RClass *klass, mrb_sym a, mrb_sym b)
+{
+  mrb_alias_method(mrb, klass, a, b);
+}
+
 /*
  * call-seq:
  *   mod.to_s   -> string
@@ -1891,7 +2168,7 @@ mrb_mod_to_s(mrb_state *mrb, mrb_value klass)
 {
 
   if (mrb_sclass_p(klass)) {
-    mrb_value v = mrb_iv_get(mrb, klass, mrb_intern_lit(mrb, "__attached__"));
+    mrb_value v = mrb_iv_get(mrb, klass, MRB_SYM(__attached__));
     mrb_value str = mrb_str_new_lit(mrb, "#<Class:");
 
     if (class_ptr_p(v)) {
@@ -1927,7 +2204,7 @@ undef_method(mrb_state *mrb, struct RClass *c, mrb_sym a)
   mrb_define_method_raw(mrb, c, a, m);
 }
 
-void
+MRB_API void
 mrb_undef_method_id(mrb_state *mrb, struct RClass *c, mrb_sym a)
 {
   if (!mrb_obj_respond_to(mrb, c, a)) {
@@ -1943,11 +2220,29 @@ mrb_undef_method(mrb_state *mrb, struct RClass *c, const char *name)
 }
 
 MRB_API void
+mrb_undef_class_method_id(mrb_state *mrb, struct RClass *c, mrb_sym name)
+{
+  mrb_undef_method_id(mrb,  mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
+}
+
+MRB_API void
 mrb_undef_class_method(mrb_state *mrb, struct RClass *c, const char *name)
 {
   mrb_undef_method(mrb,  mrb_class_ptr(mrb_singleton_class(mrb, mrb_obj_value(c))), name);
 }
 
+MRB_API void
+mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym mid)
+{
+  mt_tbl *h;
+
+  MRB_CLASS_ORIGIN(c);
+  h = c->mt;
+
+  if (h && mt_del(mrb, h, mid)) return;
+  mrb_name_error(mrb, mid, "method '%n' not defined in %C", mid, c);
+}
+
 static mrb_value
 mrb_mod_undef(mrb_state *mrb, mrb_value mod)
 {
@@ -2207,6 +2502,202 @@ mrb_mod_module_function(mrb_state *mrb, mrb_value mod)
   return mod;
 }
 
+static struct RClass*
+mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
+{
+  struct RClass *klass = mrb_basic_ptr(obj)->c;
+
+  if (klass->tt != MRB_TT_SCLASS)
+    return klass;
+  else {
+    /* copy singleton(unnamed) class */
+    struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
+
+    switch (mrb_type(obj)) {
+    case MRB_TT_CLASS:
+    case MRB_TT_SCLASS:
+      break;
+    default:
+      clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
+      break;
+    }
+    clone->super = klass->super;
+    if (klass->iv) {
+      mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass));
+      mrb_obj_iv_set(mrb, (struct RObject*)clone, MRB_SYM(__attached__), obj);
+    }
+    if (klass->mt) {
+      clone->mt = mt_copy(mrb, klass->mt);
+    }
+    else {
+      clone->mt = mt_new(mrb);
+    }
+    clone->tt = MRB_TT_SCLASS;
+    return clone;
+  }
+}
+
+static void
+copy_class(mrb_state *mrb, mrb_value dst, mrb_value src)
+{
+  struct RClass *dc = mrb_class_ptr(dst);
+  struct RClass *sc = mrb_class_ptr(src);
+  /* if the origin is not the same as the class, then the origin and
+     the current class need to be copied */
+  if (sc->flags & MRB_FL_CLASS_IS_PREPENDED) {
+    struct RClass *c0 = sc->super;
+    struct RClass *c1 = dc;
+
+    /* copy prepended iclasses */
+    while (!(c0->flags & MRB_FL_CLASS_IS_ORIGIN)) {
+      c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
+      c1 = c1->super;
+      c0 = c0->super;
+    }
+    c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
+    c1->super->flags |= MRB_FL_CLASS_IS_ORIGIN;
+  }
+  if (sc->mt) {
+    dc->mt = mt_copy(mrb, sc->mt);
+  }
+  else {
+    dc->mt = mt_new(mrb);
+  }
+  dc->super = sc->super;
+  MRB_SET_INSTANCE_TT(dc, MRB_INSTANCE_TT(sc));
+}
+
+/* 15.3.1.3.16 */
+static mrb_value
+mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
+{
+  mrb_value orig = mrb_get_arg1(mrb);
+
+  if (mrb_obj_equal(mrb, self, orig)) return self;
+  if ((mrb_type(self) != mrb_type(orig)) || (mrb_obj_class(mrb, self) != mrb_obj_class(mrb, orig))) {
+      mrb_raise(mrb, E_TYPE_ERROR, "initialize_copy should take same class object");
+  }
+  return self;
+}
+
+static void
+init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
+{
+  switch (mrb_type(obj)) {
+    case MRB_TT_ICLASS:
+      copy_class(mrb, dest, obj);
+      return;
+    case MRB_TT_CLASS:
+    case MRB_TT_MODULE:
+      copy_class(mrb, dest, obj);
+      mrb_iv_copy(mrb, dest, obj);
+      mrb_iv_remove(mrb, dest, MRB_SYM(__classname__));
+      break;
+    case MRB_TT_OBJECT:
+    case MRB_TT_SCLASS:
+    case MRB_TT_HASH:
+    case MRB_TT_DATA:
+    case MRB_TT_EXCEPTION:
+      mrb_iv_copy(mrb, dest, obj);
+      break;
+    case MRB_TT_ISTRUCT:
+      mrb_istruct_copy(dest, obj);
+      break;
+
+    default:
+      break;
+  }
+  if (!mrb_func_basic_p(mrb, dest, MRB_SYM(initialize_copy), mrb_obj_init_copy)) {
+    mrb_funcall_id(mrb, dest, MRB_SYM(initialize_copy), 1, obj);
+  }
+}
+
+/* 15.3.1.3.8  */
+/*
+ *  call-seq:
+ *     obj.clone -> an_object
+ *
+ *  Produces a shallow copy of <i>obj</i>---the instance variables of
+ *  <i>obj</i> are copied, but not the objects they reference. Copies
+ *  the frozen state of <i>obj</i>. See also the discussion
+ *  under <code>Object#dup</code>.
+ *
+ *     class Klass
+ *        attr_accessor :str
+ *     end
+ *     s1 = Klass.new      #=> #<Klass:0x401b3a38>
+ *     s1.str = "Hello"    #=> "Hello"
+ *     s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
+ *     s2.str[1,4] = "i"   #=> "i"
+ *     s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
+ *     s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"
+ *
+ *  This method may have class-specific behavior.  If so, that
+ *  behavior will be documented under the #+initialize_copy+ method of
+ *  the class.
+ *
+ *  Some Class(True False Nil Symbol Integer Float) Object  cannot clone.
+ */
+MRB_API mrb_value
+mrb_obj_clone(mrb_state *mrb, mrb_value self)
+{
+  struct RObject *p;
+  mrb_value clone;
+
+  if (mrb_immediate_p(self)) {
+    return self;
+  }
+  if (mrb_sclass_p(self)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "can't clone singleton class");
+  }
+  p = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
+  p->c = mrb_singleton_class_clone(mrb, self);
+  mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)p->c);
+  clone = mrb_obj_value(p);
+  init_copy(mrb, clone, self);
+  p->flags |= mrb_obj_ptr(self)->flags & MRB_FL_OBJ_IS_FROZEN;
+
+  return clone;
+}
+
+/* 15.3.1.3.9  */
+/*
+ *  call-seq:
+ *     obj.dup -> an_object
+ *
+ *  Produces a shallow copy of <i>obj</i>---the instance variables of
+ *  <i>obj</i> are copied, but not the objects they reference.
+ *  <code>dup</code> copies the frozen state of <i>obj</i>. See also
+ *  the discussion under <code>Object#clone</code>. In general,
+ *  <code>clone</code> and <code>dup</code> may have different semantics
+ *  in descendant classes. While <code>clone</code> is used to duplicate
+ *  an object, including its internal state, <code>dup</code> typically
+ *  uses the class of the descendant object to create the new instance.
+ *
+ *  This method may have class-specific behavior.  If so, that
+ *  behavior will be documented under the #+initialize_copy+ method of
+ *  the class.
+ */
+
+MRB_API mrb_value
+mrb_obj_dup(mrb_state *mrb, mrb_value obj)
+{
+  struct RBasic *p;
+  mrb_value dup;
+
+  if (mrb_immediate_p(obj)) {
+    return obj;
+  }
+  if (mrb_sclass_p(obj)) {
+    mrb_raise(mrb, E_TYPE_ERROR, "can't dup singleton class");
+  }
+  p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj));
+  dup = mrb_obj_value(p);
+  init_copy(mrb, dup, obj);
+
+  return dup;
+}
+
 /* implementation of __id__ */
 mrb_value mrb_obj_id_m(mrb_state *mrb, mrb_value self);
 /* implementation of instance_eval */
@@ -2229,29 +2720,27 @@ static const mrb_code new_iseq[] = {
   OP_RETURN, 0x0             /* OP_RETURN    R0 */
 };
 
+const mrb_sym new_syms[] = { MRB_SYM(allocate), MRB_SYM(initialize) };
+static const mrb_irep new_irep = {
+  3, 6, 0, MRB_IREP_STATIC,
+  new_iseq, NULL, new_syms, NULL, NULL, NULL,
+  sizeof(new_iseq), 0, 2, 0, 0,
+};
+
 static void
 init_class_new(mrb_state *mrb, struct RClass *cls)
 {
   struct RProc *p;
   mrb_method_t m;
-  mrb_irep *new_irep = (mrb_irep*)mrb_malloc(mrb, sizeof(mrb_irep));
-  static const mrb_irep mrb_irep_zero = { 0 };
-
-  *new_irep = mrb_irep_zero;
-  new_irep->syms = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym)*2);
-  new_irep->syms[0] = mrb_intern_lit(mrb, "allocate");
-  new_irep->syms[1] = mrb_intern_lit(mrb, "initialize");
-  new_irep->slen = 2;
-  new_irep->flags = MRB_ISEQ_NO_FREE;
-  new_irep->iseq = new_iseq;
-  new_irep->ilen = sizeof(new_iseq);
-  new_irep->nregs = 6;
-  new_irep->nlocals = 3;
-  p = mrb_proc_new(mrb, new_irep);
+
+  p = mrb_proc_new(mrb, &new_irep);
   MRB_METHOD_FROM_PROC(m, p);
-  mrb_define_method_raw(mrb, cls, mrb_intern_lit(mrb, "new"), m);
+  mrb_define_method_raw(mrb, cls, MRB_SYM(new), m);
 }
 
+/* implementation of #send method */
+mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+
 void
 mrb_init_class(mrb_state *mrb)
 {
@@ -2273,16 +2762,16 @@ mrb_init_class(mrb_state *mrb)
   make_metaclass(mrb, cls);
 
   /* name basic classes */
-  mrb_define_const(mrb, bob, "BasicObject", mrb_obj_value(bob));
-  mrb_define_const(mrb, obj, "Object",      mrb_obj_value(obj));
-  mrb_define_const(mrb, obj, "Module",      mrb_obj_value(mod));
-  mrb_define_const(mrb, obj, "Class",       mrb_obj_value(cls));
+  mrb_define_const_id(mrb, bob, MRB_SYM(BasicObject), mrb_obj_value(bob));
+  mrb_define_const_id(mrb, obj, MRB_SYM(Object),      mrb_obj_value(obj));
+  mrb_define_const_id(mrb, obj, MRB_SYM(Module),      mrb_obj_value(mod));
+  mrb_define_const_id(mrb, obj, MRB_SYM(Class),       mrb_obj_value(cls));
 
   /* name each classes */
-  mrb_class_name_class(mrb, NULL, bob, mrb_intern_lit(mrb, "BasicObject"));
-  mrb_class_name_class(mrb, NULL, obj, mrb_intern_lit(mrb, "Object")); /* 15.2.1 */
-  mrb_class_name_class(mrb, NULL, mod, mrb_intern_lit(mrb, "Module")); /* 15.2.2 */
-  mrb_class_name_class(mrb, NULL, cls, mrb_intern_lit(mrb, "Class"));  /* 15.2.3 */
+  mrb_class_name_class(mrb, NULL, bob, MRB_SYM(BasicObject));
+  mrb_class_name_class(mrb, NULL, obj, MRB_SYM(Object)); /* 15.2.1 */
+  mrb_class_name_class(mrb, NULL, mod, MRB_SYM(Module)); /* 15.2.2 */
+  mrb_class_name_class(mrb, NULL, cls, MRB_SYM(Class));  /* 15.2.3 */
 
   mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class);  /* 15.2.17 */
   MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC);
diff --git a/src/codedump.c b/src/codedump.c
index 649be176b..3f0801929 100644
--- a/src/codedump.c
+++ b/src/codedump.c
@@ -4,26 +4,20 @@
 #include <mruby/opcode.h>
 #include <mruby/string.h>
 #include <mruby/proc.h>
+#include <mruby/dump.h>
 
 #ifndef MRB_DISABLE_STDIO
 static void
-print_r(mrb_state *mrb, mrb_irep *irep, size_t n)
+print_r(mrb_state *mrb, const mrb_irep *irep, size_t n)
 {
-  size_t i;
-
   if (n == 0) return;
-
-  for (i=0; i+1<irep->nlocals; i++) {
-    if (irep->lv[i].r == n) {
-      mrb_sym sym = irep->lv[i].name;
-      printf(" R%d:%s", (int)n, mrb_sym_dump(mrb, sym));
-      break;
-    }
-  }
+  if (n > irep->nlocals) return;
+  if (!irep->lv[n-1]) return;
+  printf(" R%d:%s", (int)n, mrb_sym_dump(mrb, irep->lv[n-1]));
 }
 
 static void
-print_lv_a(mrb_state *mrb, mrb_irep *irep, uint16_t a)
+print_lv_a(mrb_state *mrb, const mrb_irep *irep, uint16_t a)
 {
   if (!irep->lv || a >= irep->nlocals || a == 0) {
     printf("\n");
@@ -35,7 +29,7 @@ print_lv_a(mrb_state *mrb, mrb_irep *irep, uint16_t a)
 }
 
 static void
-print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b)
+print_lv_ab(mrb_state *mrb, const mrb_irep *irep, uint16_t a, uint16_t b)
 {
   if (!irep->lv || (a >= irep->nlocals && b >= irep->nlocals) || a+b == 0) {
     printf("\n");
@@ -48,7 +42,7 @@ print_lv_ab(mrb_state *mrb, mrb_irep *irep, uint16_t a, uint16_t b)
 }
 
 static void
-print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i)
+print_header(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t i)
 {
   int32_t line;
 
@@ -63,10 +57,10 @@ print_header(mrb_state *mrb, mrb_irep *irep, ptrdiff_t i)
   printf("%03d ", (int)i);
 }
 
-#define CASE(insn,ops) case insn: FETCH_ ## ops (); L_ ## insn
+#define CASE(insn,ops) case insn: FETCH_ ## ops ();
 
 static void
-codedump(mrb_state *mrb, mrb_irep *irep)
+codedump(mrb_state *mrb, const mrb_irep *irep)
 {
   int ai;
   const mrb_code *pc, *pcend;
@@ -82,9 +76,36 @@ codedump(mrb_state *mrb, mrb_irep *irep)
 
     printf("local variable names:\n");
     for (i = 1; i < irep->nlocals; ++i) {
-      char const *s = mrb_sym_dump(mrb, irep->lv[i - 1].name);
-      int n = irep->lv[i - 1].r ? irep->lv[i - 1].r : i;
-      printf("  R%d:%s\n", n, s ? s : "");
+      char const *s = mrb_sym_dump(mrb, irep->lv[i - 1]);
+      printf("  R%d:%s\n", i, s ? s : "");
+    }
+  }
+
+  if (irep->clen > 0) {
+    int i = irep->clen;
+    const struct mrb_irep_catch_handler *e = mrb_irep_catch_handler_table(irep);
+
+    for (; i > 0; i --, e ++) {
+      int begin = bin_to_uint16(e->begin);
+      int end = bin_to_uint16(e->end);
+      int target = bin_to_uint16(e->target);
+      char buf[20];
+      const char *type;
+
+      switch (e->type) {
+        case MRB_CATCH_RESCUE:
+          type = "rescue";
+          break;
+        case MRB_CATCH_ENSURE:
+          type = "ensure";
+          break;
+        default:
+          buf[0] = '\0';
+          snprintf(buf, sizeof(buf), "0x%02x <unknown>", (int)e->type);
+          type = buf;
+          break;
+      }
+      printf("catch type: %-8s begin: %04d end: %04d target: %04d\n", type, begin, end, target);
     }
   }
 
@@ -107,159 +128,173 @@ codedump(mrb_state *mrb, mrb_irep *irep)
     print_header(mrb, irep, i);
     ins = READ_B();
     switch (ins) {
-    CASE(OP_NOP, Z):
+    CASE(OP_NOP, Z);
       printf("OP_NOP\n");
       break;
-    CASE(OP_MOVE, BB):
+    CASE(OP_MOVE, BB);
       printf("OP_MOVE\tR%d\tR%d\t", a, b);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_LOADL, BB):
-      {
-        mrb_value v = irep->pool[b];
-        mrb_value s = mrb_inspect(mrb, v);
-        printf("OP_LOADL\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s));
+    CASE(OP_LOADL, BB);
+      switch (irep->pool[b].tt) {
+      case IREP_TT_FLOAT:
+        printf("OP_LOADL\tR%d\tL(%d)\t; %f", a, b, (double)irep->pool[b].u.f);
+        break;
+      case IREP_TT_INT32:
+        printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId32, a, b, irep->pool[b].u.i32);
+        break;
+#ifdef MRB_64BIT
+      case IREP_TT_INT64:
+        printf("OP_LOADL\tR%d\tL(%d)\t; %" PRId64, a, b, irep->pool[b].u.i64);
+        break;
+#endif
+      default:
+        printf("OP_LOADL\tR%d\tL(%d)\t", a, b);
+        break;
       }
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADI, BB):
+    CASE(OP_LOADI, BB);
       printf("OP_LOADI\tR%d\t%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADINEG, BB):
+    CASE(OP_LOADINEG, BB);
       printf("OP_LOADI\tR%d\t-%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADI16, BS):
+    CASE(OP_LOADI16, BS);
       printf("OP_LOADI16\tR%d\t%d\t", a, (int)(int16_t)b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADI__1, B):
+    CASE(OP_LOADI__1, B);
       printf("OP_LOADI__1\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADI_0, B): goto L_LOADI;
-    CASE(OP_LOADI_1, B): goto L_LOADI;
-    CASE(OP_LOADI_2, B): goto L_LOADI;
-    CASE(OP_LOADI_3, B): goto L_LOADI;
-    CASE(OP_LOADI_4, B): goto L_LOADI;
-    CASE(OP_LOADI_5, B): goto L_LOADI;
-    CASE(OP_LOADI_6, B): goto L_LOADI;
-    CASE(OP_LOADI_7, B):
+    CASE(OP_LOADI_0, B); goto L_LOADI;
+    CASE(OP_LOADI_1, B); goto L_LOADI;
+    CASE(OP_LOADI_2, B); goto L_LOADI;
+    CASE(OP_LOADI_3, B); goto L_LOADI;
+    CASE(OP_LOADI_4, B); goto L_LOADI;
+    CASE(OP_LOADI_5, B); goto L_LOADI;
+    CASE(OP_LOADI_6, B); goto L_LOADI;
+    CASE(OP_LOADI_7, B);
     L_LOADI:
       printf("OP_LOADI_%d\tR%d\t\t", ins-(int)OP_LOADI_0, a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADSYM, BB):
+    CASE(OP_LOADSYM, BB);
       printf("OP_LOADSYM\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADNIL, B):
+    CASE(OP_LOADNIL, B);
       printf("OP_LOADNIL\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADSELF, B):
+    CASE(OP_LOADSELF, B);
       printf("OP_LOADSELF\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADT, B):
+    CASE(OP_LOADT, B);
       printf("OP_LOADT\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LOADF, B):
+    CASE(OP_LOADF, B);
       printf("OP_LOADF\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETGV, BB):
+    CASE(OP_GETGV, BB);
       printf("OP_GETGV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETGV, BB):
-      printf("OP_SETGV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
+    CASE(OP_SETGV, BB);
+      printf("OP_SETGV\t;%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETSV, BB):
+    CASE(OP_GETSV, BB);
       printf("OP_GETSV\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETSV, BB):
+    CASE(OP_SETSV, BB);
       printf("OP_SETSV\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETCONST, BB):
+    CASE(OP_GETCONST, BB);
       printf("OP_GETCONST\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETCONST, BB):
+    CASE(OP_SETCONST, BB);
       printf("OP_SETCONST\t:%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETMCNST, BB):
+    CASE(OP_GETMCNST, BB);
       printf("OP_GETMCNST\tR%d\tR%d::%s", a, a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETMCNST, BB):
+    CASE(OP_SETMCNST, BB);
       printf("OP_SETMCNST\tR%d::%s\tR%d", a+1, mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETIV, BB):
+    CASE(OP_GETIV, BB);
       printf("OP_GETIV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETIV, BB):
+    CASE(OP_SETIV, BB);
       printf("OP_SETIV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETUPVAR, BBB):
+    CASE(OP_GETUPVAR, BBB);
       printf("OP_GETUPVAR\tR%d\t%d\t%d", a, b, c);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETUPVAR, BBB):
+    CASE(OP_SETUPVAR, BBB);
       printf("OP_SETUPVAR\tR%d\t%d\t%d", a, b, c);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_GETCV, BB):
+    CASE(OP_GETCV, BB);
       printf("OP_GETCV\tR%d\t%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SETCV, BB):
+    CASE(OP_SETCV, BB);
       printf("OP_SETCV\t%s\tR%d", mrb_sym_dump(mrb, irep->syms[b]), a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_JMP, S):
+    CASE(OP_JMP, S);
       printf("OP_JMP\t\t%03d\n", a);
       break;
-    CASE(OP_JMPIF, BS):
+    CASE(OP_JMPUW, S);
+      printf("OP_JMPUW\t\t%03d\n", a);
+      break;
+    CASE(OP_JMPIF, BS);
       printf("OP_JMPIF\tR%d\t%03d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_JMPNOT, BS):
+    CASE(OP_JMPNOT, BS);
       printf("OP_JMPNOT\tR%d\t%03d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_JMPNIL, BS):
+    CASE(OP_JMPNIL, BS);
       printf("OP_JMPNIL\tR%d\t%03d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SENDV, BB):
+    CASE(OP_SENDV, BB);
       printf("OP_SENDV\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
       break;
-    CASE(OP_SENDVB, BB):
+    CASE(OP_SENDVB, BB);
       printf("OP_SENDVB\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
       break;
-    CASE(OP_SEND, BBB):
+    CASE(OP_SEND, BBB);
       printf("OP_SEND\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
       break;
-    CASE(OP_SENDB, BBB):
+    CASE(OP_SENDB, BBB);
       printf("OP_SENDB\tR%d\t:%s\t%d\n", a, mrb_sym_dump(mrb, irep->syms[b]), c);
       break;
-    CASE(OP_CALL, Z):
+    CASE(OP_CALL, Z);
       printf("OP_CALL\n");
       break;
-    CASE(OP_SUPER, BB):
+    CASE(OP_SUPER, BB);
       printf("OP_SUPER\tR%d\t%d\n", a, b);
       break;
-    CASE(OP_ARGARY, BS):
+    CASE(OP_ARGARY, BS);
       printf("OP_ARGARY\tR%d\t%d:%d:%d:%d (%d)", a,
              (b>>11)&0x3f,
              (b>>10)&0x1,
@@ -268,7 +303,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
              (b>>0)&0xf);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ENTER, W):
+    CASE(OP_ENTER, W);
       printf("OP_ENTER\t%d:%d:%d:%d:%d:%d:%d\n",
              MRB_ASPEC_REQ(a),
              MRB_ASPEC_OPT(a),
@@ -278,30 +313,30 @@ codedump(mrb_state *mrb, mrb_irep *irep)
              MRB_ASPEC_KDICT(a),
              MRB_ASPEC_BLOCK(a));
       break;
-    CASE(OP_KEY_P, BB):
+    CASE(OP_KEY_P, BB);
       printf("OP_KEY_P\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_KEYEND, Z):
+    CASE(OP_KEYEND, Z);
       printf("OP_KEYEND\n");
       break;
-    CASE(OP_KARG, BB):
+    CASE(OP_KARG, BB);
       printf("OP_KARG\tR%d\t:%s\t", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_RETURN, B):
+    CASE(OP_RETURN, B);
       printf("OP_RETURN\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_RETURN_BLK, B):
+    CASE(OP_RETURN_BLK, B);
       printf("OP_RETURN_BLK\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_BREAK, B):
+    CASE(OP_BREAK, B);
       printf("OP_BREAK\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_BLKPUSH, BS):
+    CASE(OP_BLKPUSH, BS);
       printf("OP_BLKPUSH\tR%d\t%d:%d:%d:%d (%d)", a,
              (b>>11)&0x3f,
              (b>>10)&0x1,
@@ -310,219 +345,178 @@ codedump(mrb_state *mrb, mrb_irep *irep)
              (b>>0)&0xf);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_LAMBDA, BB):
+    CASE(OP_LAMBDA, BB);
       printf("OP_LAMBDA\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
       break;
-    CASE(OP_BLOCK, BB):
+    CASE(OP_BLOCK, BB);
       printf("OP_BLOCK\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
       break;
-    CASE(OP_METHOD, BB):
+    CASE(OP_METHOD, BB);
       printf("OP_METHOD\tR%d\tI(%d:%p)\n", a, b, irep->reps[b]);
       break;
-    CASE(OP_RANGE_INC, B):
+    CASE(OP_RANGE_INC, B);
       printf("OP_RANGE_INC\tR%d\n", a);
       break;
-    CASE(OP_RANGE_EXC, B):
+    CASE(OP_RANGE_EXC, B);
       printf("OP_RANGE_EXC\tR%d\n", a);
       break;
-    CASE(OP_DEF, BB):
+    CASE(OP_DEF, BB);
       printf("OP_DEF\tR%d\t:%s\n", a, mrb_sym_dump(mrb, irep->syms[b]));
       break;
-    CASE(OP_UNDEF, B):
+    CASE(OP_UNDEF, B);
       printf("OP_UNDEF\t:%s\n", mrb_sym_dump(mrb, irep->syms[a]));
       break;
-    CASE(OP_ALIAS, BB):
+    CASE(OP_ALIAS, BB);
       printf("OP_ALIAS\t:%s\t%s\n", mrb_sym_dump(mrb, irep->syms[a]), mrb_sym_dump(mrb, irep->syms[b]));
       break;
-    CASE(OP_ADD, B):
+    CASE(OP_ADD, B);
       printf("OP_ADD\tR%d\t\n", a);
       break;
-    CASE(OP_ADDI, BB):
+    CASE(OP_ADDI, BB);
       printf("OP_ADDI\tR%d\t%d\n", a, b);
       break;
-    CASE(OP_SUB, B):
+    CASE(OP_SUB, B);
       printf("OP_SUB\tR%d\t\n", a);
       break;
-    CASE(OP_SUBI, BB):
+    CASE(OP_SUBI, BB);
       printf("OP_SUBI\tR%d\t%d\n", a, b);
       break;
-    CASE(OP_MUL, B):
+    CASE(OP_MUL, B);
       printf("OP_MUL\tR%d\t\n", a);
       break;
-    CASE(OP_DIV, B):
+    CASE(OP_DIV, B);
       printf("OP_DIV\tR%d\t\n", a);
       break;
-    CASE(OP_LT, B):
+    CASE(OP_LT, B);
       printf("OP_LT\t\tR%d\t\n", a);
       break;
-    CASE(OP_LE, B):
+    CASE(OP_LE, B);
       printf("OP_LE\t\tR%d\t\n", a);
       break;
-    CASE(OP_GT, B):
+    CASE(OP_GT, B);
       printf("OP_GT\t\tR%d\t\n", a);
       break;
-    CASE(OP_GE, B):
+    CASE(OP_GE, B);
       printf("OP_GE\t\tR%d\t\n", a);
       break;
-    CASE(OP_EQ, B):
+    CASE(OP_EQ, B);
       printf("OP_EQ\t\tR%d\t\n", a);
       break;
-    CASE(OP_ARRAY, BB):
+    CASE(OP_ARRAY, BB);
       printf("OP_ARRAY\tR%d\t%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ARRAY2, BBB):
+    CASE(OP_ARRAY2, BBB);
       printf("OP_ARRAY\tR%d\tR%d\t%d\t", a, b, c);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_ARYCAT, B):
+    CASE(OP_ARYCAT, B);
       printf("OP_ARYCAT\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ARYPUSH, B):
+    CASE(OP_ARYPUSH, B);
       printf("OP_ARYPUSH\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ARYDUP, B):
+    CASE(OP_ARYDUP, B);
       printf("OP_ARYDUP\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_AREF, BBB):
+    CASE(OP_AREF, BBB);
       printf("OP_AREF\tR%d\tR%d\t%d", a, b, c);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_ASET, BBB):
+    CASE(OP_ASET, BBB);
       printf("OP_ASET\tR%d\tR%d\t%d", a, b, c);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_APOST, BBB):
+    CASE(OP_APOST, BBB);
       printf("OP_APOST\tR%d\t%d\t%d", a, b, c);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_INTERN, B):
+    CASE(OP_INTERN, B);
       printf("OP_INTERN\tR%d", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_STRING, BB):
-      {
-        mrb_value v = irep->pool[b];
-        mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
-        printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, RSTRING_PTR(s));
+    CASE(OP_STRING, BB);
+      if ((irep->pool[b].tt & IREP_TT_NFLAG) == 0) {
+        printf("OP_STRING\tR%d\tL(%d)\t; %s", a, b, irep->pool[b].u.str);
+      }
+      else {
+        printf("OP_STRING\tR%d\tL(%d)\t", a, b);
       }
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_STRCAT, B):
+    CASE(OP_STRCAT, B);
       printf("OP_STRCAT\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_HASH, BB):
+    CASE(OP_HASH, BB);
       printf("OP_HASH\tR%d\t%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_HASHADD, BB):
+    CASE(OP_HASHADD, BB);
       printf("OP_HASHADD\tR%d\t%d\t", a, b);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_HASHCAT, B):
+    CASE(OP_HASHCAT, B);
       printf("OP_HASHCAT\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
 
-    CASE(OP_OCLASS, B):
+    CASE(OP_OCLASS, B);
       printf("OP_OCLASS\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_CLASS, BB):
+    CASE(OP_CLASS, BB);
       printf("OP_CLASS\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_MODULE, BB):
+    CASE(OP_MODULE, BB);
       printf("OP_MODULE\tR%d\t:%s", a, mrb_sym_dump(mrb, irep->syms[b]));
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_EXEC, BB):
+    CASE(OP_EXEC, BB);
       printf("OP_EXEC\tR%d\tI(%d:%p)", a, b, irep->reps[b]);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_SCLASS, B):
+    CASE(OP_SCLASS, B);
       printf("OP_SCLASS\tR%d\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_TCLASS, B):
+    CASE(OP_TCLASS, B);
       printf("OP_TCLASS\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_ERR, B):
-      {
-        mrb_value v = irep->pool[a];
-        mrb_value s = mrb_str_dump(mrb, mrb_str_new(mrb, RSTRING_PTR(v), RSTRING_LEN(v)));
-        printf("OP_ERR\t%s\n", RSTRING_PTR(s));
+    CASE(OP_ERR, B);
+      if ((irep->pool[a].tt & IREP_TT_NFLAG) == 0) {
+        printf("OP_ERR\t%s\n", irep->pool[a].u.str);
+      }
+      else {
+        printf("OP_ERR\tL(%d)\n", a);
       }
       break;
-    CASE(OP_EPUSH, B):
-      printf("OP_EPUSH\t\t:I(%d:%p)\n", a, irep->reps[a]);
-      break;
-    CASE(OP_ONERR, S):
-      printf("OP_ONERR\t%03d\n", a);
-      break;
-    CASE(OP_EXCEPT, B):
+    CASE(OP_EXCEPT, B);
       printf("OP_EXCEPT\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_RESCUE, BB):
+    CASE(OP_RESCUE, BB);
       printf("OP_RESCUE\tR%d\tR%d", a, b);
       print_lv_ab(mrb, irep, a, b);
       break;
-    CASE(OP_RAISE, B):
-      printf("OP_RAISE\tR%d\t\t", a);
+    CASE(OP_RAISEIF, B);
+      printf("OP_RAISEIF\tR%d\t\t", a);
       print_lv_a(mrb, irep, a);
       break;
-    CASE(OP_POPERR, B):
-      printf("OP_POPERR\t%d\t\t\n", a);
-      break;
-    CASE(OP_EPOP, B):
-      printf("OP_EPOP\t%d\n", a);
-      break;
 
-    CASE(OP_DEBUG, BBB):
+    CASE(OP_DEBUG, BBB);
       printf("OP_DEBUG\t%d\t%d\t%d\n", a, b, c);
       break;
 
-    CASE(OP_STOP, Z):
+    CASE(OP_STOP, Z);
       printf("OP_STOP\n");
       break;
 
-    CASE(OP_EXT1, Z):
-      ins = READ_B();
-      printf("OP_EXT1\n");
-      print_header(mrb, irep, pc-irep->iseq-2);
-      switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _1 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      break;
-    CASE(OP_EXT2, Z):
-      ins = READ_B();
-      printf("OP_EXT2\n");
-      print_header(mrb, irep, pc-irep->iseq-2);
-      switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _2 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      break;
-    CASE(OP_EXT3, Z):
-      ins = READ_B();
-      printf("OP_EXT3\n");
-      print_header(mrb, irep, pc-irep->iseq-2);
-      switch (ins) {
-#define OPCODE(i,x) case OP_ ## i: FETCH_ ## x ## _3 (); goto L_OP_ ## i;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      break;
-
     default:
       printf("OP_unknown (0x%x)\n", ins);
       break;
@@ -533,7 +527,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
 }
 
 static void
-codedump_recur(mrb_state *mrb, mrb_irep *irep)
+codedump_recur(mrb_state *mrb, const mrb_irep *irep)
 {
   int i;
 
diff --git a/src/debug.c b/src/debug.c
index 32add68ae..dabc5a56d 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -51,7 +51,7 @@ select_line_type(const uint16_t *lines, size_t lines_len)
 }
 
 MRB_API char const*
-mrb_debug_get_filename(mrb_state *mrb, mrb_irep *irep, ptrdiff_t pc)
+mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, ptrdiff_t pc)
 {
   if (irep && pc >= 0 && pc < irep->ilen) {
     mrb_irep_debug_info_file* f = NULL;
diff --git a/src/dump.c b/src/dump.c
index a6bbe68f3..2bc1b0a53 100644
--- a/src/dump.c
+++ b/src/dump.c
@@ -13,32 +13,18 @@
 #include <mruby/numeric.h>
 #include <mruby/debug.h>
 
-#ifndef MRB_WITHOUT_FLOAT
-#ifdef MRB_USE_FLOAT
-#define MRB_FLOAT_FMT "%.9g"
-#else
+#ifndef MRB_NO_FLOAT
+#include <mruby/endian.h>
 #define MRB_FLOAT_FMT "%.17g"
 #endif
-#endif
 
-static size_t get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep);
+static size_t get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep);
 
 #if UINT32_MAX > SIZE_MAX
 # error This code cannot be built on your environment.
 #endif
 
 static size_t
-write_padding(uint8_t *buf)
-{
-  const size_t align = MRB_DUMP_ALIGNMENT;
-  size_t pad_len = -(intptr_t)buf & (align-1);
-  if (pad_len > 0) {
-    memset(buf, 0, pad_len);
-  }
-  return pad_len;
-}
-
-static size_t
 get_irep_header_size(mrb_state *mrb)
 {
   size_t size = 0;
@@ -50,7 +36,7 @@ get_irep_header_size(mrb_state *mrb)
 }
 
 static ptrdiff_t
-write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
+write_irep_header(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
 {
   uint8_t *cur = buf;
 
@@ -64,87 +50,97 @@ write_irep_header(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 
 
 static size_t
-get_iseq_block_size(mrb_state *mrb, mrb_irep *irep)
+get_iseq_block_size(mrb_state *mrb, const mrb_irep *irep)
 {
   size_t size = 0;
 
-  size += sizeof(uint32_t); /* ilen */
-  size += sizeof(uint32_t); /* max padding */
-  size += sizeof(uint32_t) * irep->ilen; /* iseq(n) */
+  size += sizeof(uint16_t); /* ilen */
+  size += irep->ilen * sizeof(mrb_code); /* iseq(n) */
 
   return size;
 }
 
 static ptrdiff_t
-write_iseq_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf, uint8_t flags)
+write_iseq_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf, uint8_t flags)
 {
   uint8_t *cur = buf;
 
-  cur += uint32_to_bin(irep->ilen, cur); /* number of opcode */
-  cur += write_padding(cur);
+  cur += uint16_to_bin(irep->ilen, cur); /* number of opcode */
   memcpy(cur, irep->iseq, irep->ilen * sizeof(mrb_code));
   cur += irep->ilen * sizeof(mrb_code);
 
   return cur - buf;
 }
 
-#ifndef MRB_WITHOUT_FLOAT
-static mrb_value
-float_to_str(mrb_state *mrb, mrb_value flt)
+#ifndef MRB_NO_FLOAT
+static void
+dump_float(mrb_state *mrb, uint8_t *buf, mrb_float f)
 {
-  mrb_float f = mrb_float(flt);
+  /* dump IEEE754 binary in little endian */
+  union {
+    double f;
+    char s[sizeof(double)];
+  } u = {.f = (double)f};
+
+  if (littleendian) {
+    memcpy(buf, u.s, sizeof(double));
+  }
+  else {
+    size_t i;
 
-  if (isinf(f)) {
-    return f < 0 ? mrb_str_new_lit(mrb, "I") : mrb_str_new_lit(mrb, "i");
+    for (i=0; i<sizeof(double); i++) {
+      buf[i] = u.s[sizeof(double)-i-1];
+    }
   }
-  return  mrb_float_to_str(mrb, flt, MRB_FLOAT_FMT);
 }
 #endif
 
 static size_t
-get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
+get_pool_block_size(mrb_state *mrb, const mrb_irep *irep)
 {
   int pool_no;
   size_t size = 0;
-  mrb_value str;
 
-  size += sizeof(uint32_t); /* plen */
-  size += irep->plen * (sizeof(uint8_t) + sizeof(uint16_t)); /* len(n) */
+  size += sizeof(uint16_t); /* plen */
+  size += irep->plen * sizeof(uint8_t); /* len(n) */
 
   for (pool_no = 0; pool_no < irep->plen; pool_no++) {
     int ai = mrb_gc_arena_save(mrb);
 
-    switch (mrb_type(irep->pool[pool_no])) {
-    case MRB_TT_FIXNUM:
-      str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
+    switch (irep->pool[pool_no].tt) {
+    case IREP_TT_INT64:
+#ifdef MRB_64BIT
       {
-        mrb_int len = RSTRING_LEN(str);
-        mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
-        size += (size_t)len;
+        int64_t i = irep->pool[pool_no].u.i64;
+
+        if (i < INT32_MIN || INT32_MAX < i)
+          size += 8;
+        else
+          size += 4;
       }
       break;
+#else
+      /* fall through */
+#endif
+    case IREP_TT_INT32:
+      size += 4;                /* 32bits = 4bytes */
+      break;
 
-#ifndef MRB_WITHOUT_FLOAT
-    case MRB_TT_FLOAT:
-      str = float_to_str(mrb, irep->pool[pool_no]);
+    case IREP_TT_FLOAT:
+#ifndef MRB_NO_FLOAT
       {
-        mrb_int len = RSTRING_LEN(str);
-        mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
-        size += (size_t)len;
+        size += sizeof(double);
       }
-      break;
 #endif
+      break;
 
-    case MRB_TT_STRING:
+    default: /*  packed IREP_TT_STRING */ 
       {
-        mrb_int len = RSTRING_LEN(irep->pool[pool_no]);
+        mrb_int len = irep->pool[pool_no].tt >> 1; /* unpack length */
         mrb_assert_int_fit(mrb_int, len, size_t, SIZE_MAX);
-        size += (size_t)len;
+        size += (size_t)len+1;
       }
       break;
-
-    default:
-      break;
     }
     mrb_gc_arena_restore(mrb, ai);
   }
@@ -153,52 +149,63 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep)
 }
 
 static ptrdiff_t
-write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
+write_pool_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
 {
   int pool_no;
   uint8_t *cur = buf;
-  uint16_t len;
-  mrb_value str;
-  const char *char_ptr;
+  mrb_int len;
+  const char *ptr;
 
-  cur += uint32_to_bin(irep->plen, cur); /* number of pool */
+  cur += uint16_to_bin(irep->plen, cur); /* number of pool */
 
   for (pool_no = 0; pool_no < irep->plen; pool_no++) {
     int ai = mrb_gc_arena_save(mrb);
 
-    switch (mrb_type(irep->pool[pool_no])) {
-    case MRB_TT_FIXNUM:
-      cur += uint8_to_bin(IREP_TT_FIXNUM, cur); /* data type */
-      str = mrb_fixnum_to_str(mrb, irep->pool[pool_no], 10);
+    switch (irep->pool[pool_no].tt) {
+#ifdef MRB_64BIT
+    case IREP_TT_INT64:
+      {
+        int64_t i = irep->pool[pool_no].u.i64;
+        if (i < INT32_MIN || INT32_MAX < i) {
+          cur += uint8_to_bin(IREP_TT_INT64, cur); /* data type */
+          cur += uint32_to_bin((uint32_t)((i>>32) & 0xffffffff), cur); /* i64 hi */
+          cur += uint32_to_bin((uint32_t)((i    ) & 0xffffffff), cur); /* i64 lo */
+        }
+        else {
+          cur += uint8_to_bin(IREP_TT_INT32, cur); /* data type */
+          cur += uint32_to_bin(irep->pool[pool_no].u.i32, cur); /* i32 */
+        }
+      }
+      break;
+#endif
+    case IREP_TT_INT32:
+      cur += uint8_to_bin(IREP_TT_INT32, cur); /* data type */
+      cur += uint32_to_bin(irep->pool[pool_no].u.i32, cur); /* i32 */
       break;
 
-#ifndef MRB_WITHOUT_FLOAT
-    case MRB_TT_FLOAT:
+    case IREP_TT_FLOAT:
       cur += uint8_to_bin(IREP_TT_FLOAT, cur); /* data type */
-      str = float_to_str(mrb, irep->pool[pool_no]);
-      break;
+#ifndef MRB_NO_FLOAT
+      {
+        dump_float(mrb, cur,irep->pool[pool_no].u.f);
+        cur += sizeof(double);
+      }
+#else
+      cur += uint16_to_bin(0, cur); /* zero length */
 #endif
-
-    case MRB_TT_STRING:
-      cur += uint8_to_bin(IREP_TT_STRING, cur); /* data type */
-      str = irep->pool[pool_no];
       break;
 
-    default:
-      continue;
-    }
-
-    char_ptr = RSTRING_PTR(str);
-    {
-      mrb_int tlen = RSTRING_LEN(str);
-      mrb_assert_int_fit(mrb_int, tlen, uint16_t, UINT16_MAX);
-      len = (uint16_t)tlen;
+    default: /* string */
+      cur += uint8_to_bin(IREP_TT_STR, cur); /* data type */
+      ptr = irep->pool[pool_no].u.str;
+      len = irep->pool[pool_no].tt>>2;
+      mrb_assert_int_fit(mrb_int, len, uint16_t, UINT16_MAX);
+      cur += uint16_to_bin((uint16_t)len, cur); /* data length */
+      memcpy(cur, ptr, (size_t)len);
+      cur += len;
+      *cur++ = '\0';
+      break;
     }
-
-    cur += uint16_to_bin(len, cur); /* data length */
-    memcpy(cur, char_ptr, (size_t)len);
-    cur += len;
-
     mrb_gc_arena_restore(mrb, ai);
   }
 
@@ -207,13 +214,13 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 
 
 static size_t
-get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
+get_syms_block_size(mrb_state *mrb, const mrb_irep *irep)
 {
   size_t size = 0;
   int sym_no;
   mrb_int len;
 
-  size += sizeof(uint32_t); /* slen */
+  size += sizeof(uint16_t); /* slen */
   for (sym_no = 0; sym_no < irep->slen; sym_no++) {
     size += sizeof(uint16_t); /* snl(n) */
     if (irep->syms[sym_no] != 0) {
@@ -226,13 +233,13 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep)
 }
 
 static ptrdiff_t
-write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
+write_syms_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
 {
   int sym_no;
   uint8_t *cur = buf;
   const char *name;
 
-  cur += uint32_to_bin(irep->slen, cur); /* number of symbol */
+  cur += uint16_to_bin(irep->slen, cur); /* number of symbol */
 
   for (sym_no = 0; sym_no < irep->slen; sym_no++) {
     if (irep->syms[sym_no] != 0) {
@@ -255,19 +262,46 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, uint8_t *buf)
 }
 
 static size_t
-get_irep_record_size_1(mrb_state *mrb, mrb_irep *irep)
+get_catch_table_block_size(mrb_state *mrb, const mrb_irep *irep)
+{
+  size_t size = 0;
+
+  size += sizeof(uint16_t); /* number of catch handler */
+  size += (sizeof(struct mrb_irep_catch_handler)) * irep->clen;
+
+  return size;
+}
+
+static ptrdiff_t
+write_catch_table_block(mrb_state *mrb, const mrb_irep *irep, uint8_t *buf)
+{
+  uint8_t *cur = buf;
+  const struct mrb_irep_catch_handler *e = mrb_irep_catch_handler_table(irep);
+  mrb_static_assert1(sizeof(*e) == 7);
+
+  if (e == NULL) return 0;
+  /* irep->clen has already been written before iseq block */
+  memcpy(cur, (const void *)e, sizeof(*e) * irep->clen);
+  cur += sizeof(*e) * irep->clen;
+
+  return cur - buf;
+}
+
+static size_t
+get_irep_record_size_1(mrb_state *mrb, const mrb_irep *irep)
 {
   size_t size = 0;
 
   size += get_irep_header_size(mrb);
   size += get_iseq_block_size(mrb, irep);
+  size += get_catch_table_block_size(mrb, irep);
   size += get_pool_block_size(mrb, irep);
   size += get_syms_block_size(mrb, irep);
   return size;
 }
 
 static size_t
-get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
+get_irep_record_size(mrb_state *mrb, const mrb_irep *irep)
 {
   size_t size = 0;
   int irep_no;
@@ -280,7 +314,7 @@ get_irep_record_size(mrb_state *mrb, mrb_irep *irep)
 }
 
 static int
-write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags)
+write_irep_record(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, size_t *irep_record_size, uint8_t flags)
 {
   int i;
   uint8_t *src = bin;
@@ -289,13 +323,14 @@ write_irep_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *irep_rec
     return MRB_DUMP_INVALID_IREP;
   }
 
-  *irep_record_size = get_irep_record_size_1(mrb, irep);
-  if (*irep_record_size == 0) {
-    return MRB_DUMP_GENERAL_FAILURE;
-  }
-
   bin += write_irep_header(mrb, irep, bin);
+  /*
+   * The catch handler table is after iseq block, but the number of
+   * elements is placed before iseq block.
+   */
+  bin += uint16_to_bin(irep->clen, bin);
   bin += write_iseq_block(mrb, irep, bin, flags);
+  bin += write_catch_table_block(mrb, irep, bin);
   bin += write_pool_block(mrb, irep, bin);
   bin += write_syms_block(mrb, irep, bin);
 
@@ -341,7 +376,7 @@ write_section_irep_header(mrb_state *mrb, size_t section_size, uint8_t *bin)
 }
 
 static int
-write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags)
+write_section_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, size_t *len_p, uint8_t flags)
 {
   int result;
   size_t rsize = 0;
@@ -364,7 +399,7 @@ write_section_irep(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, size_t *len_p,
 }
 
 static size_t
-get_debug_record_size(mrb_state *mrb, mrb_irep *irep)
+get_debug_record_size(mrb_state *mrb, const mrb_irep *irep)
 {
   size_t ret = 0;
   uint16_t f_idx;
@@ -413,11 +448,11 @@ find_filename_index(const mrb_sym *ary, int ary_len, mrb_sym s)
 }
 
 static size_t
-get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *lp)
+get_filename_table_size(mrb_state *mrb, const mrb_irep *irep, mrb_sym **fp, uint16_t *lp)
 {
   mrb_sym *filenames = *fp;
   size_t size = 0;
-  mrb_irep_debug_info *di = irep->debug_info;
+  const mrb_irep_debug_info *di = irep->debug_info;
   int i;
 
   mrb_assert(lp);
@@ -444,7 +479,7 @@ get_filename_table_size(mrb_state *mrb, mrb_irep *irep, mrb_sym **fp, uint16_t *
 }
 
 static size_t
-write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
+write_debug_record_1(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
 {
   uint8_t *cur;
   uint16_t f_idx;
@@ -498,7 +533,7 @@ write_debug_record_1(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const
 }
 
 static size_t
-write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
+write_debug_record(mrb_state *mrb, const mrb_irep *irep, uint8_t *bin, mrb_sym const* filenames, uint16_t filenames_len)
 {
   size_t size, len;
   int irep_no;
@@ -516,7 +551,7 @@ write_debug_record(mrb_state *mrb, mrb_irep *irep, uint8_t *bin, mrb_sym const*
 }
 
 static int
-write_section_debug(mrb_state *mrb, mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len)
+write_section_debug(mrb_state *mrb, const mrb_irep *irep, uint8_t *cur, mrb_sym const *filenames, uint16_t filenames_len)
 {
   size_t section_size = 0;
   const uint8_t *bin = cur;
@@ -566,7 +601,7 @@ create_lv_sym_table(mrb_state *mrb, const mrb_irep *irep, mrb_sym **syms, uint32
   }
 
   for (i = 0; i + 1 < irep->nlocals; ++i) {
-    mrb_sym const name = irep->lv[i].name;
+    mrb_sym const name = irep->lv[i];
     if (name == 0) continue;
     if (find_filename_index(*syms, *syms_len, name) != -1) continue;
 
@@ -609,16 +644,14 @@ write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym c
   int i;
 
   for (i = 0; i + 1 < irep->nlocals; ++i) {
-    if (irep->lv[i].name == 0) {
+    if (irep->lv[i] == 0) {
       cur += uint16_to_bin(RITE_LV_NULL_MARK, cur);
-      cur += uint16_to_bin(0, cur);
     }
     else {
-      int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i].name);
+      int const sym_idx = find_filename_index(syms, syms_len, irep->lv[i]);
       mrb_assert(sym_idx != -1); /* local variable name must be in syms */
 
       cur += uint16_to_bin(sym_idx, cur);
-      cur += uint16_to_bin(irep->lv[i].r, cur);
     }
   }
 
@@ -632,12 +665,12 @@ write_lv_record(mrb_state *mrb, const mrb_irep *irep, uint8_t **start, mrb_sym c
 }
 
 static size_t
-get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
+get_lv_record_size(mrb_state *mrb, const mrb_irep *irep)
 {
   size_t ret = 0;
   int i;
 
-  ret += (sizeof(uint16_t) + sizeof(uint16_t)) * (irep->nlocals - 1);
+  ret += sizeof(uint16_t) * (irep->nlocals - 1);
 
   for (i = 0; i < irep->rlen; ++i) {
     ret += get_lv_record_size(mrb, irep->reps[i]);
@@ -647,7 +680,7 @@ get_lv_record_size(mrb_state *mrb, mrb_irep *irep)
 }
 
 static size_t
-get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len)
+get_lv_section_size(mrb_state *mrb, const mrb_irep *irep, mrb_sym const *syms, uint32_t syms_len)
 {
   size_t ret = 0, i;
 
@@ -665,7 +698,7 @@ get_lv_section_size(mrb_state *mrb, mrb_irep *irep, mrb_sym const *syms, uint32_
 }
 
 static int
-write_section_lv(mrb_state *mrb, mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len)
+write_section_lv(mrb_state *mrb, const mrb_irep *irep, uint8_t *start, mrb_sym const *syms, uint32_t const syms_len)
 {
   uint8_t *cur = start;
   struct rite_section_lv_header *header;
@@ -707,7 +740,8 @@ write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8
   uint32_t offset;
 
   memcpy(header->binary_ident, RITE_BINARY_IDENT, sizeof(header->binary_ident));
-  memcpy(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version));
+  memcpy(header->major_version, RITE_BINARY_MAJOR_VER, sizeof(header->major_version));
+  memcpy(header->minor_version, RITE_BINARY_MAJOR_VER, sizeof(header->minor_version));
   memcpy(header->compiler_name, RITE_COMPILER_NAME, sizeof(header->compiler_name));
   memcpy(header->compiler_version, RITE_COMPILER_VERSION, sizeof(header->compiler_version));
   mrb_assert(binary_size <= UINT32_MAX);
@@ -721,7 +755,7 @@ write_rite_binary_header(mrb_state *mrb, size_t binary_size, uint8_t *bin, uint8
 }
 
 static mrb_bool
-debug_info_defined_p(mrb_irep *irep)
+debug_info_defined_p(const mrb_irep *irep)
 {
   int i;
 
@@ -733,7 +767,7 @@ debug_info_defined_p(mrb_irep *irep)
 }
 
 static mrb_bool
-lv_defined_p(mrb_irep *irep)
+lv_defined_p(const mrb_irep *irep)
 {
   int i;
 
@@ -747,7 +781,7 @@ lv_defined_p(mrb_irep *irep)
 }
 
 static int
-dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
+dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
 {
   int result = MRB_DUMP_GENERAL_FAILURE;
   size_t malloc_size;
@@ -835,7 +869,7 @@ error_exit:
 }
 
 int
-mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
+mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size)
 {
   return dump_irep(mrb, irep, flags, bin, bin_size);
 }
@@ -843,7 +877,7 @@ mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size
 #ifndef MRB_DISABLE_STDIO
 
 int
-mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp)
+mrb_dump_irep_binary(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE* fp)
 {
   uint8_t *bin = NULL;
   size_t bin_size = 0;
@@ -865,7 +899,7 @@ mrb_dump_irep_binary(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE* fp)
 }
 
 int
-mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname)
+mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname)
 {
   uint8_t *bin = NULL;
   size_t bin_size = 0, bin_idx = 0;
@@ -884,15 +918,8 @@ mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, con
           "#ifdef __cplusplus\n"
           "extern const uint8_t %s[];\n"
           "#endif\n"
-          "const uint8_t\n"
-          "#if defined __GNUC__\n"
-          "__attribute__((aligned(%u)))\n"
-          "#elif defined _MSC_VER\n"
-          "__declspec(align(%u))\n"
-          "#endif\n"
-          "%s[] = {",
-          initname,
-          (uint16_t)MRB_DUMP_ALIGNMENT, (uint16_t)MRB_DUMP_ALIGNMENT, initname) < 0) {
+          "const uint8_t %s[] = {",
+          initname, initname) < 0) {
       mrb_free(mrb, bin);
       return MRB_DUMP_WRITE_FAULT;
     }
@@ -918,4 +945,171 @@ mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep *irep, uint8_t flags, FILE *fp, con
   return result;
 }
 
+static int
+dump_pool(mrb_state *mrb, const mrb_pool_value *p, FILE *fp)
+{
+  if (p->tt & IREP_TT_NFLAG) {  /* number */
+    switch (p->tt) {
+#ifdef MRB_64BIT
+    case IREP_TT_INT64:
+      if (p->u.i64 < INT32_MIN || INT32_MAX < p->u.i64) {
+        fprintf(fp, "{IREP_TT_INT64, {.i64=%" PRId64 "}},\n", p->u.i64);
+      }
+      else {
+        fprintf(fp, "{IREP_TT_INT32, {.i32=%" PRId32 "}},\n", (int32_t)p->u.i64);
+      }
+      break;
+#endif
+    case IREP_TT_INT32:
+      fprintf(fp, "{IREP_TT_INT32, {.i32=%" PRId32 "}},\n", p->u.i32);
+      break;
+    case IREP_TT_FLOAT:
+      if (p->u.f == 0) {
+        fprintf(fp, "{IREP_TT_FLOAT, {.f=%#.1f}},\n", p->u.f);
+      }
+      else {
+        fprintf(fp, "{IREP_TT_FLOAT, {.f=" MRB_FLOAT_FMT "}},\n", p->u.f);
+      }
+      break;
+    }
+  }
+  else {                        /* string */
+    int i, len = p->tt>>2;
+    const char *s = p->u.str;
+    fprintf(fp, "{IREP_TT_STR|(%d<<2), {\"", len);
+    for (i=0; i<len; i++) {
+      fprintf(fp, "\\x%02x", (int)s[i]&0xff);
+    }
+    fputs("\"}},\n", fp);
+  }
+  return MRB_DUMP_OK;
+}
+
+mrb_bool mrb_sym_static_p(mrb_state *mrb, mrb_sym sym);
+  
+static int
+dump_sym(mrb_state *mrb, mrb_sym sym, FILE *fp)
+{
+  const char *name;
+  if (sym == 0) return MRB_DUMP_INVALID_ARGUMENT;
+  name = mrb_sym_name(mrb, sym);
+  if (!name) {
+    fprintf(stderr, "undefined symbol (%d) - define presym\n", sym);
+  }
+  if (!mrb_sym_static_p(mrb, sym)) {
+    fprintf(stderr, "no static symbol (%s) - define presym\n", name);
+  }
+  fprintf(fp, "%d /* %s */,", sym, name);
+  return MRB_DUMP_OK;
+}
+
+static int
+dump_irep_struct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *name, int n, int *mp)
+{
+  int i, len;
+  int max = *mp;
+
+  /* dump reps */
+  if (irep->reps) {
+    for (i=0,len=irep->rlen; i<len; i++) {
+      *mp += len;
+      if (dump_irep_struct(mrb, irep->reps[i], flags, fp, name, max+i, mp) != MRB_DUMP_OK)
+        return MRB_DUMP_INVALID_ARGUMENT;
+    }
+    fprintf(fp,   "static const mrb_irep *%s_reps_%d[%d] = {\n", name, n, len);
+    for (i=0,len=irep->rlen; i<len; i++) {
+      fprintf(fp,   "  &%s_irep_%d,\n", name, max+i);
+    }
+    fputs("};\n", fp);
+  }
+  /* dump pool */
+  if (irep->pool) {
+    len=irep->plen;
+    fprintf(fp,   "static const mrb_pool_value %s_pool_%d[%d] = {\n", name, n, len);
+    for (i=0; i<len; i++) {
+      if (dump_pool(mrb, &irep->pool[i], fp) != MRB_DUMP_OK)
+        return MRB_DUMP_INVALID_ARGUMENT;
+    }
+    fputs("};\n", fp);
+  }
+  /* dump syms */
+  if (irep->syms) {
+    len=irep->slen;
+    fprintf(fp,   "static const mrb_sym %s_syms_%d[%d] = {", name, n, len);
+    for (i=0; i<len; i++) {
+      dump_sym(mrb, irep->syms[i], fp);
+    }
+    fputs("};\n", fp);
+  }
+  /* dump iseq */
+  len=irep->ilen+sizeof(struct mrb_irep_catch_handler)*irep->clen;
+  fprintf(fp,   "static const mrb_code %s_iseq_%d[%d] = {", name, n, len);
+  for (i=0; i<len; i++) {
+    if (i%20 == 0) fputs("\n", fp);
+    fprintf(fp, "0x%02x,", irep->iseq[i]);
+  }
+  fputs("};\n", fp);
+  /* dump lv */
+  if (irep->lv) {
+    len=irep->nlocals;
+    fprintf(fp,   "static const mrb_sym %s_lv_%d[%d] = {", name, n, len);
+    for (i=0; i+1<len; i++) {
+      fprintf(fp, "%uU, ", irep->lv[i]);
+    }
+    fputs("};\n", fp);
+  }
+  /* dump irep */
+  fprintf(fp, "static const mrb_irep %s_irep_%d = {\n", name, n);
+  fprintf(fp,   "  %d,%d,%d,\n", irep->nlocals, irep->nregs, irep->clen);
+  fprintf(fp,   "  MRB_IREP_STATIC,%s_iseq_%d,\n", name, n);
+  if (irep->pool) {
+    fprintf(fp, "  %s_pool_%d,", name, n);
+  }
+  else {
+    fputs(      "  NULL,", fp);
+  }
+  if (irep->syms) {
+    fprintf(fp, "%s_syms_%d,", name, n);
+  }
+  else {
+    fputs(      "NULL,", fp);
+  }
+  if (irep->reps) {
+    fprintf(fp, "%s_reps_%d,\n", name, n);
+  }
+  else {
+    fputs(      "NULL,\n", fp);
+  }
+  if (irep->lv) {
+    fprintf(fp, "  %s_lv_%d,\n", name, n);
+  }
+  else {
+    fputs(      "  NULL,\t\t\t\t\t/* lv */\n", fp);
+  }
+  fputs(        "  NULL,\t\t\t\t\t/* debug_info */\n", fp);
+  fprintf(fp,   "  %d,%d,%d,%d,0\n};\n", irep->ilen, irep->plen, irep->slen, irep->rlen);
+
+  return MRB_DUMP_OK;
+}
+
+int
+mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, FILE *fp, const char *initname)
+{
+  int max = 1;
+  int n;
+
+  if (fp == NULL || initname == NULL || initname[0] == '\0') {
+    return MRB_DUMP_INVALID_ARGUMENT;
+  }
+  if (fprintf(fp, "#include <mruby.h>\n" "#include <mruby/proc.h>\n\n") < 0) {
+    return MRB_DUMP_WRITE_FAULT;
+  }
+  n = dump_irep_struct(mrb, irep, flags, fp, initname, 0, &max);
+  if (n != MRB_DUMP_OK) return n;
+  fprintf(fp, "#ifdef __cplusplus\nextern const struct RProc %s[];\n#endif\n", initname);
+  fprintf(fp, "const struct RProc %s[] = {{\n", initname);
+  fprintf(fp, "NULL,NULL,MRB_TT_PROC,7,0,{&%s_irep_0},NULL,{NULL},\n}};\n", initname);
+  return MRB_DUMP_OK;
+}
+
 #endif /* MRB_DISABLE_STDIO */
diff --git a/src/enum.c b/src/enum.c
index d31370188..b95956715 100644
--- a/src/enum.c
+++ b/src/enum.c
@@ -18,7 +18,7 @@ enum_update_hash(mrb_state *mrb, mrb_value self)
   mrb_get_args(mrb, "iii", &hash, &index, &hv);
   hash ^= ((uint32_t)hv << (index % 16));
 
-  return mrb_fixnum_value(hash);
+  return mrb_int_value(mrb, hash);
 }
 
 void
diff --git a/src/error.c b/src/error.c
index 5d17209e5..b19f0ea43 100644
--- a/src/error.c
+++ b/src/error.c
@@ -45,7 +45,7 @@ exc_initialize(mrb_state *mrb, mrb_value exc)
   mrb_value mesg;
 
   if (mrb_get_args(mrb, "|o", &mesg) == 1) {
-    mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), mesg);
+    mrb_iv_set(mrb, exc, MRB_SYM(mesg), mesg);
   }
   return exc;
 }
@@ -74,7 +74,7 @@ exc_exception(mrb_state *mrb, mrb_value self)
   if (argc == 0) return self;
   if (mrb_obj_equal(mrb, self, a)) return self;
   exc = mrb_obj_clone(mrb, self);
-  mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "mesg"), a);
+  mrb_iv_set(mrb, exc, MRB_SYM(mesg), a);
 
   return exc;
 }
@@ -90,7 +90,7 @@ exc_exception(mrb_state *mrb, mrb_value self)
 mrb_value
 exc_to_s(mrb_state *mrb, mrb_value exc)
 {
-  mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg"));
+  mrb_value mesg = mrb_attr_get(mrb, exc, MRB_SYM(mesg));
   struct RObject *p;
 
   if (!mrb_string_p(mesg)) {
@@ -114,7 +114,7 @@ exc_to_s(mrb_state *mrb, mrb_value exc)
 static mrb_value
 exc_message(mrb_state *mrb, mrb_value exc)
 {
-  return mrb_funcall(mrb, exc, "to_s", 0);
+  return mrb_funcall_id(mrb, exc, MRB_SYM(to_s), 0);
 }
 
 /*
@@ -130,7 +130,7 @@ exc_message(mrb_state *mrb, mrb_value exc)
 mrb_value
 mrb_exc_inspect(mrb_state *mrb, mrb_value exc)
 {
-  mrb_value mesg = mrb_attr_get(mrb, exc, mrb_intern_lit(mrb, "mesg"));
+  mrb_value mesg = mrb_attr_get(mrb, exc, MRB_SYM(mesg));
   mrb_value cname = mrb_mod_to_s(mrb, mrb_obj_value(mrb_obj_class(mrb, exc)));
   mesg = mrb_obj_as_string(mrb, mesg);
   return RSTRING_LEN(mesg) == 0 ? cname : mrb_format(mrb, "%v (%v)", mesg, cname);
@@ -154,7 +154,7 @@ set_backtrace(mrb_state *mrb, mrb_value exc, mrb_value backtrace)
       p++;
     }
   }
-  mrb_iv_set(mrb, exc, mrb_intern_lit(mrb, "backtrace"), backtrace);
+  mrb_iv_set(mrb, exc, MRB_SYM(backtrace), backtrace);
 }
 
 static mrb_value
@@ -288,7 +288,7 @@ mrb_vformat(mrb_state *mrb, const char *format, va_list ap)
 #endif
           obj = mrb_fixnum_value(i);
           goto L_cat_obj;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
         case 'f':
           obj = mrb_float_value(mrb, (mrb_float)va_arg(ap, double));
           goto L_cat_obj;
@@ -474,7 +474,7 @@ mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv)
       n = 1;
 exception_call:
       {
-        mrb_sym exc = mrb_intern_lit(mrb, "exception");
+        mrb_sym exc = MRB_SYM(exception);
         if (mrb_respond_to(mrb, argv[0], exc)) {
           mesg = mrb_funcall_argv(mrb, argv[0], exc, n, argv+1);
         }
@@ -622,11 +622,11 @@ mrb_init_exception(mrb_state *mrb)
   script_error = mrb_define_class(mrb, "ScriptError", mrb->eException_class);                /* 15.2.37 */
   mrb_define_class(mrb, "SyntaxError", script_error);                                        /* 15.2.38 */
   stack_error = mrb_define_class(mrb, "SystemStackError", exception);
-  mrb->stack_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, stack_error, "stack level too deep"));
+  mrb->stack_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, stack_error, "stack level too deep"));
 
   nomem_error = mrb_define_class(mrb, "NoMemoryError", exception);
-  mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, nomem_error, "Out of memory"));
+  mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "Out of memory"));
 #ifdef MRB_GC_FIXED_ARENA
-  mrb->arena_err = mrb_obj_ptr(mrb_exc_new_str_lit(mrb, nomem_error, "arena overflow error"));
+  mrb->arena_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "arena overflow error"));
 #endif
 }
diff --git a/src/etc.c b/src/etc.c
index 74b9ab03b..96f95ad5f 100644
--- a/src/etc.c
+++ b/src/etc.c
@@ -8,6 +8,7 @@
 #include <mruby/string.h>
 #include <mruby/data.h>
 #include <mruby/class.h>
+#include <mruby/numeric.h>
 
 MRB_API struct RData*
 mrb_data_object_alloc(mrb_state *mrb, struct RClass *klass, void *ptr, const mrb_data_type *type)
@@ -69,21 +70,11 @@ mrb_obj_to_sym(mrb_state *mrb, mrb_value name)
   return 0;  /* not reached */
 }
 
-MRB_API mrb_int
-#ifdef MRB_WITHOUT_FLOAT
-mrb_fixnum_id(mrb_int f)
-#else
-mrb_float_id(mrb_float f)
-#endif
+static mrb_int
+make_num_id(const char *p, size_t len)
 {
-  const char *p = (const char*)&f;
-  int len = sizeof(f);
   uint32_t id = 0;
 
-#ifndef MRB_WITHOUT_FLOAT
-  /* normalize -0.0 to 0.0 */
-  if (f == 0) f = 0.0;
-#endif
   while (len--) {
     id = id*65599 + *p;
     p++;
@@ -94,6 +85,22 @@ mrb_float_id(mrb_float f)
 }
 
 MRB_API mrb_int
+mrb_int_id(mrb_int n)
+{
+  return make_num_id((const char*)&n, sizeof(n));
+}
+
+#ifndef MRB_NO_FLOAT
+MRB_API mrb_int
+mrb_float_id(mrb_float f)
+{
+  /* normalize -0.0 to 0.0 */
+  if (f == 0) f = 0.0;
+  return make_num_id((const char*)&f, sizeof(f));
+}
+#endif
+
+MRB_API mrb_int
 mrb_obj_id(mrb_value obj)
 {
   mrb_int tt = mrb_type(obj);
@@ -114,11 +121,9 @@ mrb_obj_id(mrb_value obj)
     return MakeID(2);
   case MRB_TT_SYMBOL:
     return MakeID(mrb_symbol(obj));
-  case MRB_TT_FIXNUM:
-#ifdef MRB_WITHOUT_FLOAT
-    return MakeID(mrb_fixnum_id(mrb_fixnum(obj)));
-#else
-    return MakeID2(mrb_float_id((mrb_float)mrb_fixnum(obj)), MRB_TT_FLOAT);
+  case MRB_TT_INTEGER:
+    return MakeID(mrb_int_id(mrb_integer(obj)));
+#ifdef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
     return MakeID(mrb_float_id(mrb_float(obj)));
 #endif
@@ -147,29 +152,32 @@ mrb_obj_id(mrb_value obj)
 #ifdef MRB_WORD_BOXING
 #define mrb_xxx_boxing_cptr_value mrb_word_boxing_cptr_value
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value
 mrb_word_boxing_float_value(mrb_state *mrb, mrb_float f)
 {
-  mrb_value v;
+  union mrb_value_ v;
 
-  v.value.p = mrb_obj_alloc(mrb, MRB_TT_FLOAT, mrb->float_class);
-  v.value.fp->f = f;
-  MRB_SET_FROZEN_FLAG(v.value.bp);
-  return v;
+  v.p = mrb_obj_alloc(mrb, MRB_TT_FLOAT, mrb->float_class);
+  v.fp->f = f;
+  MRB_SET_FROZEN_FLAG(v.bp);
+  return v.w;
 }
+#endif  /* MRB_NO_FLOAT */
 
 MRB_API mrb_value
-mrb_word_boxing_float_pool(mrb_state *mrb, mrb_float f)
+mrb_word_boxing_int_value(mrb_state *mrb, mrb_int n)
 {
-  struct RFloat *nf = (struct RFloat *)mrb_malloc(mrb, sizeof(struct RFloat));
-  nf->tt = MRB_TT_FLOAT;
-  nf->c = mrb->float_class;
-  nf->f = f;
-  MRB_SET_FROZEN_FLAG(nf);
-  return mrb_obj_value(nf);
+  if (FIXABLE(n)) return mrb_fixnum_value(n);
+  else {
+    union mrb_value_ v;
+
+    v.p = mrb_obj_alloc(mrb, MRB_TT_INTEGER, mrb->integer_class);
+    v.ip->i = n;
+    MRB_SET_FROZEN_FLAG(v.ip);
+    return v.w;
+  }
 }
-#endif  /* MRB_WITHOUT_FLOAT */
 #endif  /* MRB_WORD_BOXING */
 
 #if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT))
diff --git a/src/fmt_fp.c b/src/fmt_fp.c
index 81ace6ec8..2c1e13c36 100644
--- a/src/fmt_fp.c
+++ b/src/fmt_fp.c
@@ -1,4 +1,4 @@
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #if defined(MRB_DISABLE_STDIO) || defined(_WIN32) || defined(_WIN64)
 /*
 
diff --git a/src/gc.c b/src/gc.c
index 5531207db..0f2c3bfab 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -6,6 +6,9 @@
 
 #include <string.h>
 #include <stdlib.h>
+#ifdef MRB_USE_MALLOC_TRIM
+#include <malloc.h>
+#endif
 #include <mruby.h>
 #include <mruby/array.h>
 #include <mruby/class.h>
@@ -35,6 +38,11 @@
     * Gray - Marked, But the child objects are unmarked.
     * Black - Marked, the child objects are also marked.
 
+  Extra color
+
+    * Red - Static (ROM object) no need to be collected.
+          - All child objects should be Red as well.
+
   == Two White Types
 
   There're two white color types in a flip-flop fashion: White-A and White-B,
@@ -117,7 +125,7 @@ typedef struct {
     struct RException exc;
     struct RBreak brk;
 #ifdef MRB_WORD_BOXING
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     struct RFloat floatv;
 #endif
     struct RCptr cptr;
@@ -185,6 +193,7 @@ gettimeofday_time(void)
 #define GC_WHITE_A 1
 #define GC_WHITE_B (1 << 1)
 #define GC_BLACK (1 << 2)
+#define GC_RED 7
 #define GC_WHITES (GC_WHITE_A | GC_WHITE_B)
 #define GC_COLOR_MASK 7
 
@@ -194,7 +203,8 @@ gettimeofday_time(void)
 #define paint_partial_white(s, o) ((o)->color = (s)->current_white_part)
 #define is_gray(o) ((o)->color == GC_GRAY)
 #define is_white(o) ((o)->color & GC_WHITES)
-#define is_black(o) ((o)->color & GC_BLACK)
+#define is_black(o) ((o)->color == GC_BLACK)
+#define is_red(o) ((o)->color == GC_RED)
 #define flip_white_part(s) ((s)->current_white_part = other_white_part(s))
 #define other_white_part(s) ((s)->current_white_part ^ GC_WHITES)
 #define is_dead(s, o) (((o)->color & other_white_part(s) & GC_WHITES) || (o)->tt == MRB_TT_FREE)
@@ -581,11 +591,11 @@ add_gray_list(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
   gc->gray_list = obj;
 }
 
-static int
+static mrb_int
 ci_nregs(mrb_callinfo *ci)
 {
-  struct RProc *p = ci->proc;
-  int n = 0;
+  const struct RProc *p = ci->proc;
+  mrb_int n = 0;
 
   if (!p) {
     if (ci->argc < 0) return 3;
@@ -633,7 +643,6 @@ mark_context_stack(mrb_state *mrb, struct mrb_context *c)
 static void
 mark_context(mrb_state *mrb, struct mrb_context *c)
 {
-  int i;
   mrb_callinfo *ci;
 
  start:
@@ -650,10 +659,6 @@ mark_context(mrb_state *mrb, struct mrb_context *c)
       mrb_gc_mark(mrb, (struct RBasic*)ci->target_class);
     }
   }
-  /* mark ensure stack */
-  for (i=0; i<c->eidx; i++) {
-    mrb_gc_mark(mrb, (struct RBasic*)c->ensure[i]);
-  }
   /* mark fibers */
   mrb_gc_mark(mrb, (struct RBasic*)c->fib);
   if (c->prev) {
@@ -765,6 +770,7 @@ mrb_gc_mark(mrb_state *mrb, struct RBasic *obj)
 {
   if (obj == 0) return;
   if (!is_white(obj)) return;
+  if (is_red(obj)) return;
   mrb_assert((obj)->tt != MRB_TT_FREE);
   add_gray_list(mrb, &mrb->gc, obj);
 }
@@ -776,12 +782,12 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end)
   switch (obj->tt) {
     /* immediate - no mark */
   case MRB_TT_TRUE:
-  case MRB_TT_FIXNUM:
+  case MRB_TT_INTEGER:
   case MRB_TT_SYMBOL:
     /* cannot happen */
     return;
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
 #ifdef MRB_WORD_BOXING
     break;
@@ -803,12 +809,14 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end)
   case MRB_TT_SCLASS:
     mrb_gc_free_mt(mrb, (struct RClass*)obj);
     mrb_gc_free_iv(mrb, (struct RObject*)obj);
-    mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
+    if (!end)
+      mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
     break;
   case MRB_TT_ICLASS:
     if (MRB_FLAG_TEST(obj, MRB_FL_CLASS_IS_ORIGIN))
       mrb_gc_free_mt(mrb, (struct RClass*)obj);
-    mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
+    if (!end)
+      mrb_mc_clear_by_class(mrb, (struct RClass*)obj);
     break;
   case MRB_TT_ENV:
     {
@@ -868,7 +876,7 @@ obj_free(mrb_state *mrb, struct RBasic *obj, int end)
       struct RProc *p = (struct RProc*)obj;
 
       if (!MRB_PROC_CFUNC_P(p) && p->body.irep) {
-        mrb_irep *irep = p->body.irep;
+        mrb_irep *irep = (mrb_irep*)p->body.irep;
         if (end) {
           mrb_irep_cutref(mrb, irep);
         }
@@ -924,10 +932,10 @@ root_scan_phase(mrb_state *mrb, mrb_gc *gc)
   mrb_gc_mark(mrb, (struct RBasic*)mrb->hash_class);
   mrb_gc_mark(mrb, (struct RBasic*)mrb->range_class);
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_gc_mark(mrb, (struct RBasic*)mrb->float_class);
 #endif
-  mrb_gc_mark(mrb, (struct RBasic*)mrb->fixnum_class);
+  mrb_gc_mark(mrb, (struct RBasic*)mrb->integer_class);
   mrb_gc_mark(mrb, (struct RBasic*)mrb->true_class);
   mrb_gc_mark(mrb, (struct RBasic*)mrb->false_class);
   mrb_gc_mark(mrb, (struct RBasic*)mrb->nil_class);
@@ -1004,9 +1012,6 @@ gc_gray_counts(mrb_state *mrb, mrb_gc *gc, struct RBasic *obj)
       if (c->stbase + i > c->stend) i = c->stend - c->stbase;
       children += i;
 
-      /* mark ensure stack */
-      children += c->eidx;
-
       /* mark closure */
       if (c->cibase) {
         for (i=0, ci = c->cibase; ci <= c->ci; i++, ci++)
@@ -1317,6 +1322,9 @@ mrb_full_gc(mrb_state *mrb)
     gc->full = FALSE;
   }
 
+#ifdef MRB_USE_MALLOC_TRIM
+  malloc_trim(0);
+#endif
   GC_TIME_STOP_AND_REPORT;
 }
 
diff --git a/src/hash.c b/src/hash.c
index c891e1b22..d67fa6254 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -11,7 +11,7 @@
 #include <mruby/string.h>
 #include <mruby/variable.h>
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /* a function to get hash value of a float number */
 mrb_int mrb_float_id(mrb_float f);
 #endif
@@ -64,16 +64,16 @@ ht_hash_func(mrb_state *mrb, htable *t, mrb_value key)
   case MRB_TT_TRUE:
   case MRB_TT_FALSE:
   case MRB_TT_SYMBOL:
-  case MRB_TT_FIXNUM:
-#ifndef MRB_WITHOUT_FLOAT
+  case MRB_TT_INTEGER:
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
 #endif
     h = (size_t)mrb_obj_id(key);
     break;
 
   default:
-    hv = mrb_funcall(mrb, key, "hash", 0);
-    h = (size_t)tt ^ (size_t)mrb_fixnum(hv);
+    hv = mrb_funcall_id(mrb, key, MRB_SYM(hash), 0);
+    h = (size_t)tt ^ (size_t)mrb_integer(hv);
     break;
   }
   if (index && (index != t->index || capa != index->capa)) {
@@ -95,28 +95,14 @@ ht_hash_equal(mrb_state *mrb, htable *t, mrb_value a, mrb_value b)
     if (!mrb_symbol_p(b)) return FALSE;
     return mrb_symbol(a) == mrb_symbol(b);
 
-  case MRB_TT_FIXNUM:
-    switch (mrb_type(b)) {
-    case MRB_TT_FIXNUM:
-      return mrb_fixnum(a) == mrb_fixnum(b);
-#ifndef MRB_WITHOUT_FLOAT
-    case MRB_TT_FLOAT:
-      return (mrb_float)mrb_fixnum(a) == mrb_float(b);
-#endif
-    default:
-      return FALSE;
-    }
+  case MRB_TT_INTEGER:
+    if (!mrb_integer_p(b)) return FALSE;
+    return mrb_integer(a) == mrb_integer(b);
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
-    switch (mrb_type(b)) {
-    case MRB_TT_FIXNUM:
-      return mrb_float(a) == (mrb_float)mrb_fixnum(b);
-    case MRB_TT_FLOAT:
-      return mrb_float(a) == mrb_float(b);
-    default:
-      return FALSE;
-    }
+    if (!mrb_float_p(b)) return FALSE;
+    return mrb_float(a) == mrb_float(b);
 #endif
 
   default:
@@ -589,7 +575,7 @@ ht_free(mrb_state *mrb, htable *t)
   mrb_free(mrb, t);
 }
 
-static void mrb_hash_modify(mrb_state *mrb, mrb_value hash);
+static void hash_modify(mrb_state *mrb, mrb_value hash);
 
 static inline mrb_value
 ht_key(mrb_state *mrb, mrb_value key)
@@ -683,7 +669,7 @@ mrb_hash_init_copy(mrb_state *mrb, mrb_value self)
   vret = mrb_obj_value(copy);
   ifnone = RHASH_IFNONE(self);
   if (!mrb_nil_p(ifnone)) {
-      mrb_iv_set(mrb, vret, mrb_intern_lit(mrb, "ifnone"), ifnone);
+    mrb_iv_set(mrb, vret, MRB_SYM(ifnone), ifnone);
   }
   return vret;
 }
@@ -729,7 +715,7 @@ mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
     return val;
   }
 
-  mid = mrb_intern_lit(mrb, "default");
+  mid = MRB_SYM(default);
   if (mrb_func_basic_p(mrb, hash, mid, mrb_hash_default)) {
     return hash_default(mrb, hash, key);
   }
@@ -752,7 +738,7 @@ mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def)
 MRB_API void
 mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
 {
-  mrb_hash_modify(mrb, hash);
+  hash_modify(mrb, hash);
 
   key = KEY(key);
   ht_put(mrb, RHASH_TBL(hash), key, val);
@@ -762,7 +748,7 @@ mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
 }
 
 static void
-mrb_hash_modify(mrb_state *mrb, mrb_value hash)
+hash_modify(mrb_state *mrb, mrb_value hash)
 {
   mrb_check_frozen(mrb, mrb_hash_ptr(hash));
   if (!RHASH_TBL(hash)) {
@@ -814,7 +800,7 @@ mrb_hash_init(mrb_state *mrb, mrb_value hash)
 
   ifnone = mrb_nil_value();
   mrb_get_args(mrb, "&|o?", &block, &ifnone, &ifnone_p);
-  mrb_hash_modify(mrb, hash);
+  hash_modify(mrb, hash);
   if (!mrb_nil_p(block)) {
     if (ifnone_p) {
       mrb_argnum_error(mrb, 1, 0, 0);
@@ -824,7 +810,7 @@ mrb_hash_init(mrb_state *mrb, mrb_value hash)
   }
   if (!mrb_nil_p(ifnone)) {
     RHASH(hash)->flags |= MRB_HASH_DEFAULT;
-    mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
+    mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
   }
   return hash;
 }
@@ -856,7 +842,7 @@ hash_default(mrb_state *mrb, mrb_value hash, mrb_value key)
 {
   if (MRB_RHASH_DEFAULT_P(hash)) {
     if (MRB_RHASH_PROCDEFAULT_P(hash)) {
-      return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
+      return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, key);
     }
     else {
       return RHASH_IFNONE(hash);
@@ -897,7 +883,7 @@ mrb_hash_default(mrb_state *mrb, mrb_value hash)
   if (MRB_RHASH_DEFAULT_P(hash)) {
     if (MRB_RHASH_PROCDEFAULT_P(hash)) {
       if (!given) return mrb_nil_value();
-      return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
+      return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, key);
     }
     else {
       return RHASH_IFNONE(hash);
@@ -932,8 +918,8 @@ mrb_hash_set_default(mrb_state *mrb, mrb_value hash)
 {
   mrb_value ifnone = mrb_get_arg1(mrb);
 
-  mrb_hash_modify(mrb, hash);
-  mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
+  hash_modify(mrb, hash);
+  mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
   RHASH(hash)->flags &= ~MRB_HASH_PROC_DEFAULT;
   if (!mrb_nil_p(ifnone)) {
     RHASH(hash)->flags |= MRB_HASH_DEFAULT;
@@ -987,8 +973,8 @@ mrb_hash_set_default_proc(mrb_state *mrb, mrb_value hash)
 {
   mrb_value ifnone = mrb_get_arg1(mrb);
 
-  mrb_hash_modify(mrb, hash);
-  mrb_iv_set(mrb, hash, mrb_intern_lit(mrb, "ifnone"), ifnone);
+  hash_modify(mrb, hash);
+  mrb_iv_set(mrb, hash, MRB_SYM(ifnone), ifnone);
   if (!mrb_nil_p(ifnone)) {
     RHASH(hash)->flags |= MRB_HASH_PROC_DEFAULT;
     RHASH(hash)->flags |= MRB_HASH_DEFAULT;
@@ -1020,7 +1006,7 @@ mrb_hash_delete(mrb_state *mrb, mrb_value self)
 {
   mrb_value key = mrb_get_arg1(mrb);
 
-  mrb_hash_modify(mrb, self);
+  hash_modify(mrb, self);
   return mrb_hash_delete_key(mrb, self, key);
 }
 
@@ -1070,7 +1056,7 @@ mrb_hash_shift(mrb_state *mrb, mrb_value hash)
 {
   htable *t = RHASH_TBL(hash);
 
-  mrb_hash_modify(mrb, hash);
+  hash_modify(mrb, hash);
   if (t && t->size > 0) {
     mrb_value del_key = mrb_nil_value();
     mrb_value del_val = mrb_nil_value();
@@ -1083,7 +1069,7 @@ mrb_hash_shift(mrb_state *mrb, mrb_value hash)
 
   if (MRB_RHASH_DEFAULT_P(hash)) {
     if (MRB_RHASH_PROCDEFAULT_P(hash)) {
-      return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, mrb_nil_value());
+      return mrb_funcall_id(mrb, RHASH_PROCDEFAULT(hash), MRB_SYM(call), 2, hash, mrb_nil_value());
     }
     else {
       return RHASH_IFNONE(hash);
@@ -1109,7 +1095,7 @@ mrb_hash_clear(mrb_state *mrb, mrb_value hash)
 {
   htable *t = RHASH_TBL(hash);
 
-  mrb_hash_modify(mrb, hash);
+  hash_modify(mrb, hash);
   if (t) {
     ht_free(mrb, t);
     RHASH_TBL(hash) = NULL;
@@ -1368,7 +1354,7 @@ mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2)
 {
   htable *h1, *h2;
 
-  mrb_hash_modify(mrb, hash1);
+  hash_modify(mrb, hash1);
   hash2 = mrb_ensure_hash_type(mrb, hash2);
   h1 = RHASH_TBL(hash1);
   h2 = RHASH_TBL(hash2);
diff --git a/src/kernel.c b/src/kernel.c
index 10ed9f88e..c34d0bb6e 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -19,7 +19,7 @@ mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func)
 {
   struct RClass *c = mrb_class(mrb, obj);
   mrb_method_t m = mrb_method_search_vm(mrb, &c, mid);
-  struct RProc *p;
+  const struct RProc *p;
 
   if (MRB_METHOD_UNDEF_P(m)) return FALSE;
   if (MRB_METHOD_FUNC_P(m))
@@ -33,7 +33,7 @@ mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func)
 static mrb_bool
 mrb_obj_basic_to_s_p(mrb_state *mrb, mrb_value obj)
 {
-  return mrb_func_basic_p(mrb, obj, mrb_intern_lit(mrb, "to_s"), mrb_any_to_s);
+  return mrb_func_basic_p(mrb, obj, MRB_SYM(to_s), mrb_any_to_s);
 }
 
 /* 15.3.1.3.17 */
@@ -96,7 +96,7 @@ mrb_equal_m(mrb_state *mrb, mrb_value self)
 mrb_value
 mrb_obj_id_m(mrb_state *mrb, mrb_value self)
 {
-  return mrb_fixnum_value(mrb_obj_id(self));
+  return mrb_int_value(mrb, mrb_obj_id(self));
 }
 
 static int
@@ -143,7 +143,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
   mrb_value *bp;
   int bidx;
   struct REnv *e = NULL;
-  struct RProc *p;
+  const struct RProc *p;
 
   if (ci <= cibase) {
     /* toplevel does not have block */
@@ -209,7 +209,7 @@ mrb_f_block_given_p_m(mrb_state *mrb, mrb_value self)
  *  called with an explicit receiver, as <code>class</code> is also a
  *  reserved word in Ruby.
  *
- *     1.class      #=> Fixnum
+ *     1.class      #=> Integer
  *     self.class   #=> Object
  */
 static mrb_value
@@ -218,187 +218,6 @@ mrb_obj_class_m(mrb_state *mrb, mrb_value self)
   return mrb_obj_value(mrb_obj_class(mrb, self));
 }
 
-static struct RClass*
-mrb_singleton_class_clone(mrb_state *mrb, mrb_value obj)
-{
-  struct RClass *klass = mrb_basic_ptr(obj)->c;
-
-  if (klass->tt != MRB_TT_SCLASS)
-    return klass;
-  else {
-    /* copy singleton(unnamed) class */
-    struct RClass *clone = (struct RClass*)mrb_obj_alloc(mrb, klass->tt, mrb->class_class);
-
-    switch (mrb_type(obj)) {
-    case MRB_TT_CLASS:
-    case MRB_TT_SCLASS:
-      break;
-    default:
-      clone->c = mrb_singleton_class_clone(mrb, mrb_obj_value(klass));
-      break;
-    }
-    clone->super = klass->super;
-    if (klass->iv) {
-      mrb_iv_copy(mrb, mrb_obj_value(clone), mrb_obj_value(klass));
-      mrb_obj_iv_set(mrb, (struct RObject*)clone, mrb_intern_lit(mrb, "__attached__"), obj);
-    }
-    if (klass->mt) {
-      clone->mt = kh_copy(mt, mrb, klass->mt);
-    }
-    else {
-      clone->mt = kh_init(mt, mrb);
-    }
-    clone->tt = MRB_TT_SCLASS;
-    return clone;
-  }
-}
-
-static void
-copy_class(mrb_state *mrb, mrb_value dst, mrb_value src)
-{
-  struct RClass *dc = mrb_class_ptr(dst);
-  struct RClass *sc = mrb_class_ptr(src);
-  /* if the origin is not the same as the class, then the origin and
-     the current class need to be copied */
-  if (sc->flags & MRB_FL_CLASS_IS_PREPENDED) {
-    struct RClass *c0 = sc->super;
-    struct RClass *c1 = dc;
-
-    /* copy prepended iclasses */
-    while (!(c0->flags & MRB_FL_CLASS_IS_ORIGIN)) {
-      c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
-      c1 = c1->super;
-      c0 = c0->super;
-    }
-    c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0)));
-    c1->super->flags |= MRB_FL_CLASS_IS_ORIGIN;
-  }
-  if (sc->mt) {
-    dc->mt = kh_copy(mt, mrb, sc->mt);
-  }
-  else {
-    dc->mt = kh_init(mt, mrb);
-  }
-  dc->super = sc->super;
-  MRB_SET_INSTANCE_TT(dc, MRB_INSTANCE_TT(sc));
-}
-
-static void
-init_copy(mrb_state *mrb, mrb_value dest, mrb_value obj)
-{
-  switch (mrb_type(obj)) {
-    case MRB_TT_ICLASS:
-      copy_class(mrb, dest, obj);
-      return;
-    case MRB_TT_CLASS:
-    case MRB_TT_MODULE:
-      copy_class(mrb, dest, obj);
-      mrb_iv_copy(mrb, dest, obj);
-      mrb_iv_remove(mrb, dest, mrb_intern_lit(mrb, "__classname__"));
-      break;
-    case MRB_TT_OBJECT:
-    case MRB_TT_SCLASS:
-    case MRB_TT_HASH:
-    case MRB_TT_DATA:
-    case MRB_TT_EXCEPTION:
-      mrb_iv_copy(mrb, dest, obj);
-      break;
-    case MRB_TT_ISTRUCT:
-      mrb_istruct_copy(dest, obj);
-      break;
-
-    default:
-      break;
-  }
-  mrb_funcall(mrb, dest, "initialize_copy", 1, obj);
-}
-
-/* 15.3.1.3.8  */
-/*
- *  call-seq:
- *     obj.clone -> an_object
- *
- *  Produces a shallow copy of <i>obj</i>---the instance variables of
- *  <i>obj</i> are copied, but not the objects they reference. Copies
- *  the frozen state of <i>obj</i>. See also the discussion
- *  under <code>Object#dup</code>.
- *
- *     class Klass
- *        attr_accessor :str
- *     end
- *     s1 = Klass.new      #=> #<Klass:0x401b3a38>
- *     s1.str = "Hello"    #=> "Hello"
- *     s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
- *     s2.str[1,4] = "i"   #=> "i"
- *     s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
- *     s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"
- *
- *  This method may have class-specific behavior.  If so, that
- *  behavior will be documented under the #+initialize_copy+ method of
- *  the class.
- *
- *  Some Class(True False Nil Symbol Fixnum Float) Object  cannot clone.
- */
-MRB_API mrb_value
-mrb_obj_clone(mrb_state *mrb, mrb_value self)
-{
-  struct RObject *p;
-  mrb_value clone;
-
-  if (mrb_immediate_p(self)) {
-    return self;
-  }
-  if (mrb_sclass_p(self)) {
-    mrb_raise(mrb, E_TYPE_ERROR, "can't clone singleton class");
-  }
-  p = (struct RObject*)mrb_obj_alloc(mrb, mrb_type(self), mrb_obj_class(mrb, self));
-  p->c = mrb_singleton_class_clone(mrb, self);
-  mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)p->c);
-  clone = mrb_obj_value(p);
-  init_copy(mrb, clone, self);
-  p->flags |= mrb_obj_ptr(self)->flags & MRB_FL_OBJ_IS_FROZEN;
-
-  return clone;
-}
-
-/* 15.3.1.3.9  */
-/*
- *  call-seq:
- *     obj.dup -> an_object
- *
- *  Produces a shallow copy of <i>obj</i>---the instance variables of
- *  <i>obj</i> are copied, but not the objects they reference.
- *  <code>dup</code> copies the frozen state of <i>obj</i>. See also
- *  the discussion under <code>Object#clone</code>. In general,
- *  <code>clone</code> and <code>dup</code> may have different semantics
- *  in descendant classes. While <code>clone</code> is used to duplicate
- *  an object, including its internal state, <code>dup</code> typically
- *  uses the class of the descendant object to create the new instance.
- *
- *  This method may have class-specific behavior.  If so, that
- *  behavior will be documented under the #+initialize_copy+ method of
- *  the class.
- */
-
-MRB_API mrb_value
-mrb_obj_dup(mrb_state *mrb, mrb_value obj)
-{
-  struct RBasic *p;
-  mrb_value dup;
-
-  if (mrb_immediate_p(obj)) {
-    return obj;
-  }
-  if (mrb_sclass_p(obj)) {
-    mrb_raise(mrb, E_TYPE_ERROR, "can't dup singleton class");
-  }
-  p = mrb_obj_alloc(mrb, mrb_type(obj), mrb_obj_class(mrb, obj));
-  dup = mrb_obj_value(p);
-  init_copy(mrb, dup, obj);
-
-  return dup;
-}
-
 static mrb_value
 mrb_obj_extend(mrb_state *mrb, mrb_int argc, mrb_value *argv, mrb_value obj)
 {
@@ -411,8 +230,8 @@ mrb_obj_extend(mrb_state *mrb, mrb_int argc, mrb_value *argv, mrb_value obj)
     mrb_check_type(mrb, argv[i], MRB_TT_MODULE);
   }
   while (argc--) {
-    mrb_funcall(mrb, argv[argc], "extend_object", 1, obj);
-    mrb_funcall(mrb, argv[argc], "extended", 1, obj);
+    mrb_funcall_id(mrb, argv[argc], MRB_SYM(extend_object), 1, obj);
+    mrb_funcall_id(mrb, argv[argc], MRB_SYM(extended), 1, obj);
   }
   return obj;
 }
@@ -476,20 +295,20 @@ mrb_obj_frozen(mrb_state *mrb, mrb_value self)
  *  call-seq:
  *     obj.hash    -> fixnum
  *
- *  Generates a <code>Fixnum</code> hash value for this object. This
+ *  Generates a <code>Integer</code> hash value for this object. This
  *  function must have the property that <code>a.eql?(b)</code> implies
  *  <code>a.hash == b.hash</code>. The hash value is used by class
  *  <code>Hash</code>. Any hash value that exceeds the capacity of a
- *  <code>Fixnum</code> will be truncated before being used.
+ *  <code>Integer</code> will be truncated before being used.
  */
 static mrb_value
 mrb_obj_hash(mrb_state *mrb, mrb_value self)
 {
-  return mrb_fixnum_value(mrb_obj_id(self));
+  return mrb_int_value(mrb, mrb_obj_id(self));
 }
 
 /* 15.3.1.3.16 */
-static mrb_value
+mrb_value
 mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
 {
   mrb_value orig = mrb_get_arg1(mrb);
@@ -501,7 +320,6 @@ mrb_obj_init_copy(mrb_state *mrb, mrb_value self)
   return self;
 }
 
-
 MRB_API mrb_bool
 mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c)
 {
@@ -564,9 +382,6 @@ mrb_obj_is_kind_of_m(mrb_state *mrb, mrb_value self)
   return mrb_bool_value(mrb_obj_is_kind_of(mrb, self, c));
 }
 
-KHASH_DECLARE(st, mrb_sym, char, FALSE)
-KHASH_DEFINE(st, mrb_sym, char, FALSE, kh_int_hash_func, kh_int_hash_equal)
-
 /* 15.3.1.3.32 */
 /*
  * call_seq:
@@ -749,7 +564,7 @@ obj_respond_to(mrb_state *mrb, mrb_value self)
   mrb_get_args(mrb, "n|b", &id, &priv);
   respond_to_p = basic_obj_respond_to(mrb, self, id, !priv);
   if (!respond_to_p) {
-    rtm_id = mrb_intern_lit(mrb, "respond_to_missing?");
+    rtm_id = MRB_QSYM(respond_to_missing_p);
     if (basic_obj_respond_to(mrb, self, rtm_id, !priv)) {
       mrb_value args[2], v;
       args[0] = mrb_symbol_value(id);
@@ -766,7 +581,7 @@ mrb_obj_ceqq(mrb_state *mrb, mrb_value self)
 {
   mrb_value v = mrb_get_arg1(mrb);
   mrb_int i, len;
-  mrb_sym eqq = mrb_intern_lit(mrb, "===");
+  mrb_sym eqq = MRB_QSYM(eqq);
   mrb_value ary;
 
   if (mrb_array_p(self)) {
diff --git a/src/load.c b/src/load.c
index 247d511df..c1a8c4c87 100644
--- a/src/load.c
+++ b/src/load.c
@@ -15,6 +15,7 @@
 #include <mruby/debug.h>
 #include <mruby/error.h>
 #include <mruby/data.h>
+#include <mruby/endian.h>
 
 #if SIZE_MAX < UINT32_MAX
 # error size_t must be at least 32 bits wide
@@ -26,31 +27,32 @@
 #define SIZE_ERROR_MUL(nmemb, size) ((size_t)(nmemb) > SIZE_MAX / (size))
 
 static size_t
-skip_padding(const uint8_t *buf)
-{
-  const size_t align = MRB_DUMP_ALIGNMENT;
-  return -(intptr_t)buf & (align-1);
-}
-
-static size_t
 offset_crc_body(void)
 {
   struct rite_binary_header header;
   return ((uint8_t *)header.binary_crc - (uint8_t *)&header) + sizeof(header.binary_crc);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
-double mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck);
-
+#ifndef MRB_NO_FLOAT
 static double
-str_to_double(mrb_state *mrb, const char *p, size_t len)
+str_to_double(mrb_state *mrb, const char *p)
 {
-  /* `i`, `inf`, `infinity` */
-  if (len > 0 && p[0] == 'i') return INFINITY;
-
-  /* `I`, `-inf`, `-infinity` */
-  if (p[0] == 'I' || (len > 1 && p[0] == '-' && p[1] == 'i')) return -INFINITY;
-  return mrb_str_len_to_dbl(mrb, p, len, TRUE);
+  /* dump IEEE754 little endian binary */
+  union {
+    char s[sizeof(double)];
+    double f;
+  } u;
+
+  if (littleendian) {
+    memcpy(u.s, p, sizeof(double));
+  }
+  else {
+    size_t i;
+    for (i=0; i<sizeof(double); i++) {
+      u.s[i] = p[sizeof(double)-i-1];
+    }
+  }
+  return u.f;
 }
 #endif
 
@@ -73,8 +75,10 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag
   uint16_t tt, pool_data_len, snl;
   int plen;
   struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
-  mrb_irep *irep = mrb_add_irep(mrb);
+  mrb_pool_value *pool;
+  mrb_sym *syms;
   int ai = mrb_gc_arena_save(mrb);
+  mrb_irep *irep = mrb_add_irep(mrb);
 
   irep_obj->data = irep;
 
@@ -94,110 +98,137 @@ read_irep_record_1(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flag
   src += sizeof(uint16_t);
 
   /* Binary Data Section */
-  /* ISEQ BLOCK */
-  irep->ilen = (uint16_t)bin_to_uint32(src);
-  src += sizeof(uint32_t);
-  src += skip_padding(src);
+  /* ISEQ BLOCK (and CATCH HANDLER TABLE BLOCK) */
+  irep->clen = bin_to_uint16(src);  /* number of catch handler */
+  src += sizeof(uint16_t);
+  irep->ilen = bin_to_uint16(src);
+  src += sizeof(uint16_t);
 
   if (irep->ilen > 0) {
+    size_t data_len = sizeof(mrb_code) * irep->ilen +
+                      sizeof(struct mrb_irep_catch_handler) * irep->clen;
+    mrb_static_assert1(sizeof(struct mrb_irep_catch_handler) == 7);
     if (SIZE_ERROR_MUL(irep->ilen, sizeof(mrb_code))) {
       return NULL;
     }
     if ((flags & FLAG_SRC_MALLOC) == 0) {
       irep->iseq = (mrb_code*)src;
-      src += sizeof(mrb_code) * irep->ilen;
       irep->flags |= MRB_ISEQ_NO_FREE;
     }
     else {
-      size_t data_len = sizeof(mrb_code) * irep->ilen;
       void *buf = mrb_malloc(mrb, data_len);
       irep->iseq = (mrb_code *)buf;
       memcpy(buf, src, data_len);
-      src += data_len;
     }
+    src += data_len;
   }
 
   /* POOL BLOCK */
-  plen = bin_to_uint32(src); /* number of pool */
-  src += sizeof(uint32_t);
+  plen = bin_to_uint16(src); /* number of pool */
+  src += sizeof(uint16_t);
   if (plen > 0) {
     if (SIZE_ERROR_MUL(plen, sizeof(mrb_value))) {
       return NULL;
     }
-    irep->pool = (mrb_value*)mrb_malloc(mrb, sizeof(mrb_value) * plen);
+    irep->pool = pool = (mrb_pool_value*)mrb_calloc(mrb, sizeof(mrb_pool_value), plen);
 
     for (i = 0; i < plen; i++) {
-      const char *s;
       mrb_bool st = (flags & FLAG_SRC_MALLOC)==0;
 
       tt = *src++; /* pool TT */
-      pool_data_len = bin_to_uint16(src); /* pool data length */
-      src += sizeof(uint16_t);
-      s = (const char*)src;
-      src += pool_data_len;
       switch (tt) { /* pool data */
-      case IREP_TT_FIXNUM: {
-        mrb_value num = mrb_str_len_to_inum(mrb, s, pool_data_len, 10, FALSE);
-#ifdef MRB_WITHOUT_FLOAT
-        irep->pool[i] = num;
+      case IREP_TT_INT32:
+        {
+          mrb_int v = (int32_t)bin_to_uint32(src);
+          src += sizeof(uint32_t);
+#ifdef MRB_64BIT
+          pool[i].tt = IREP_TT_INT64;
+          pool[i].u.i64 = (int64_t)v;
 #else
-        irep->pool[i] = mrb_float_p(num)? mrb_float_pool(mrb, mrb_float(num)) : num;
+          pool[i].tt = IREP_TT_INT32;
+          pool[i].u.i32 = v;
 #endif
         }
         break;
+      case IREP_TT_INT64:
+#ifdef MRB_64BIT
+        {
+          uint64_t i = bin_to_uint32(src);
+          src += sizeof(uint32_t);
+          i <<= 32;
+          i |= bin_to_uint32(src);
+          src += sizeof(uint32_t);
+          pool[i].u.i64 = (int64_t)i;
+        }
+        break;
+#else
+        return NULL;            /* INT64 not supported on MRB_32BIT */
+#endif
 
-#ifndef MRB_WITHOUT_FLOAT
       case IREP_TT_FLOAT:
-        irep->pool[i] = mrb_float_pool(mrb, str_to_double(mrb, s, pool_data_len));
+#ifndef MRB_NO_FLOAT
+        pool[i].tt = tt;
+         pool[i].u.f = str_to_double(mrb, (const char*)src);
+        src += sizeof(double);
         break;
+#else
+        return NULL;            /* MRB_NO_FLOAT */
 #endif
 
-      case IREP_TT_STRING:
-        irep->pool[i] = mrb_str_pool(mrb, s, pool_data_len, st);
+      case IREP_TT_STR:
+        pool_data_len = bin_to_uint16(src); /* pool data length */
+        src += sizeof(uint16_t);
+        if (st) {
+          pool[i].tt = (pool_data_len<<2) | IREP_TT_SSTR;
+          pool[i].u.str = (const char*)src;
+        }
+        else {
+          char *p;
+          pool[i].tt = (pool_data_len<<2) | IREP_TT_STR;
+          p = (char*)mrb_malloc(mrb, pool_data_len+1);
+          memcpy(p, src, pool_data_len+1);
+          pool[i].u.str = (const char*)p;
+        }
+        src += pool_data_len + 1;
         break;
 
       default:
         /* should not happen */
-        irep->pool[i] = mrb_nil_value();
-        break;
+        return NULL;
       }
-      irep->plen++;
-      mrb_gc_arena_restore(mrb, ai);
+      irep->plen = i+1;
     }
   }
 
   /* SYMS BLOCK */
-  irep->slen = (uint16_t)bin_to_uint32(src);  /* syms length */
-  src += sizeof(uint32_t);
+  irep->slen = bin_to_uint16(src);  /* syms length */
+  src += sizeof(uint16_t);
   if (irep->slen > 0) {
     if (SIZE_ERROR_MUL(irep->slen, sizeof(mrb_sym))) {
       return NULL;
     }
-    irep->syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
+    irep->syms = syms = (mrb_sym *)mrb_malloc(mrb, sizeof(mrb_sym) * irep->slen);
 
     for (i = 0; i < irep->slen; i++) {
       snl = bin_to_uint16(src);               /* symbol name length */
       src += sizeof(uint16_t);
 
       if (snl == MRB_DUMP_NULL_SYM_LEN) {
-        irep->syms[i] = 0;
+        syms[i] = 0;
         continue;
       }
 
       if (flags & FLAG_SRC_MALLOC) {
-        irep->syms[i] = mrb_intern(mrb, (char *)src, snl);
+        syms[i] = mrb_intern(mrb, (char *)src, snl);
       }
       else {
-        irep->syms[i] = mrb_intern_static(mrb, (char *)src, snl);
+        syms[i] = mrb_intern_static(mrb, (char *)src, snl);
       }
       src += snl + 1;
-
       mrb_gc_arena_restore(mrb, ai);
     }
   }
 
-  irep->reps = (mrb_irep**)mrb_calloc(mrb, irep->rlen, sizeof(mrb_irep*));
-
   diff = src - bin;
   mrb_assert_int_fit(ptrdiff_t, diff, size_t, SIZE_MAX);
   *len = (size_t)diff;
@@ -213,6 +244,7 @@ read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
   struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
   int ai = mrb_gc_arena_save(mrb);
   mrb_irep *irep = read_irep_record_1(mrb, bin, len, flags);
+  mrb_irep **reps;
   int i;
 
   mrb_gc_arena_restore(mrb, ai);
@@ -220,15 +252,17 @@ read_irep_record(mrb_state *mrb, const uint8_t *bin, size_t *len, uint8_t flags)
     return NULL;
   }
 
+  reps = (mrb_irep**)mrb_calloc(mrb, irep->rlen, sizeof(mrb_irep*));
+  irep->reps = (const mrb_irep**)reps;
   irep_obj->data = irep;
 
   bin += *len;
   for (i=0; i<irep->rlen; i++) {
     size_t rlen;
 
-    irep->reps[i] = read_irep_record(mrb, bin, &rlen, flags);
+    reps[i] = read_irep_record(mrb, bin, &rlen, flags);
     mrb_gc_arena_restore(mrb, ai);
-    if (irep->reps[i] == NULL) {
+    if (reps[i] == NULL) {
       return NULL;
     }
     bin += rlen;
@@ -257,25 +291,26 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
   size_t record_size;
   uint16_t f_idx;
   int i;
+  mrb_irep_debug_info *debug;
 
   if (irep->debug_info) { return MRB_DUMP_INVALID_IREP; }
 
-  irep->debug_info = (mrb_irep_debug_info*)mrb_calloc(mrb, 1, sizeof(mrb_irep_debug_info));
-  irep->debug_info->pc_count = (uint32_t)irep->ilen;
+  irep->debug_info = debug = (mrb_irep_debug_info*)mrb_calloc(mrb, 1, sizeof(mrb_irep_debug_info));
+  debug->pc_count = (uint32_t)irep->ilen;
 
   record_size = (size_t)bin_to_uint32(bin);
   bin += sizeof(uint32_t);
 
-  irep->debug_info->flen = bin_to_uint16(bin);
-  irep->debug_info->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*));
+  debug->flen = bin_to_uint16(bin);
+  debug->files = (mrb_irep_debug_info_file**)mrb_calloc(mrb, irep->debug_info->flen, sizeof(mrb_irep_debug_info*));
   bin += sizeof(uint16_t);
 
-  for (f_idx = 0; f_idx < irep->debug_info->flen; ++f_idx) {
+  for (f_idx = 0; f_idx < debug->flen; ++f_idx) {
     mrb_irep_debug_info_file *file;
     uint16_t filename_idx;
 
     file = (mrb_irep_debug_info_file *)mrb_calloc(mrb, 1, sizeof(*file));
-    irep->debug_info->files[f_idx] = file;
+    debug->files[f_idx] = file;
 
     file->start_pos = bin_to_uint32(bin);
     bin += sizeof(uint32_t);
@@ -329,7 +364,7 @@ read_debug_record(mrb_state *mrb, const uint8_t *start, mrb_irep* irep, size_t *
     size_t len;
     int ret;
 
-    ret = read_debug_record(mrb, bin, irep->reps[i], &len, filenames, filenames_len);
+    ret = read_debug_record(mrb, bin, (mrb_irep*)irep->reps[i], &len, filenames, filenames_len);
     if (ret != MRB_DUMP_OK) return ret;
     bin += len;
   }
@@ -393,34 +428,31 @@ static int
 read_lv_record(mrb_state *mrb, const uint8_t *start, mrb_irep *irep, size_t *record_len, mrb_sym const *syms, uint32_t syms_len)
 {
   const uint8_t *bin = start;
+  mrb_sym *lv;
   ptrdiff_t diff;
   int i;
 
-  irep->lv = (struct mrb_locals*)mrb_malloc(mrb, sizeof(struct mrb_locals) * (irep->nlocals - 1));
+  irep->lv = lv = (mrb_sym*)mrb_malloc(mrb, sizeof(mrb_sym) * (irep->nlocals - 1));
 
   for (i = 0; i + 1< irep->nlocals; ++i) {
     uint16_t const sym_idx = bin_to_uint16(bin);
     bin += sizeof(uint16_t);
     if (sym_idx == RITE_LV_NULL_MARK) {
-      irep->lv[i].name = 0;
-      irep->lv[i].r = 0;
+      lv[i] = 0;
     }
     else {
       if (sym_idx >= syms_len) {
         return MRB_DUMP_GENERAL_FAILURE;
       }
-      irep->lv[i].name = syms[sym_idx];
-
-      irep->lv[i].r = bin_to_uint16(bin);
+      lv[i] = syms[sym_idx];
     }
-    bin += sizeof(uint16_t);
   }
 
   for (i = 0; i < irep->rlen; ++i) {
     size_t len;
     int ret;
 
-    ret = read_lv_record(mrb, bin, irep->reps[i], &len, syms, syms_len);
+    ret = read_lv_record(mrb, bin, (mrb_irep*)irep->reps[i], &len, syms, syms_len);
     if (ret != MRB_DUMP_OK) return ret;
     bin += len;
   }
@@ -491,7 +523,12 @@ read_binary_header(const uint8_t *bin, size_t bufsize, size_t *bin_size, uint16_
     return MRB_DUMP_INVALID_FILE_HEADER;
   }
 
-  if (memcmp(header->binary_version, RITE_BINARY_FORMAT_VER, sizeof(header->binary_version)) != 0) {
+  /* if major version is different, they are incompatible */
+  if (memcmp(header->major_version, RITE_BINARY_MAJOR_VER, sizeof(header->major_version)) != 0) {
+    return MRB_DUMP_INVALID_FILE_HEADER;
+  }
+  /* if minor version is different, we can accept the older version */
+  if (memcmp(header->minor_version, RITE_BINARY_MINOR_VER, sizeof(header->minor_version)) <= 0) {
     return MRB_DUMP_INVALID_FILE_HEADER;
   }
 
@@ -587,7 +624,7 @@ void mrb_exc_set(mrb_state *mrb, mrb_value exc);
 static void
 irep_error(mrb_state *mrb)
 {
-  mrb_exc_set(mrb, mrb_exc_new_str_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
+  mrb_exc_set(mrb, mrb_exc_new_lit(mrb, E_SCRIPT_ERROR, "irep load error"));
 }
 
 void mrb_codedump_all(mrb_state*, struct RProc*);
@@ -642,6 +679,12 @@ mrb_load_irep_buf(mrb_state *mrb, const void *buf, size_t bufsize)
   return mrb_load_irep_buf_cxt(mrb, buf, bufsize, NULL);
 }
 
+MRB_API mrb_value
+mrb_load_proc(mrb_state *mrb, const struct RProc *proc)
+{
+  return mrb_vm_run(mrb, proc, mrb_top_self(mrb), 0);
+}
+
 #ifndef MRB_DISABLE_STDIO
 
 mrb_irep*
diff --git a/src/numeric.c b/src/numeric.c
index f4961928b..e1898301e 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -1,10 +1,10 @@
 /*
-** numeric.c - Numeric, Integer, Float, Fixnum class
+** numeric.c - Numeric, Integer, Float class
 **
 ** See Copyright Notice in mruby.h
 */
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #include <float.h>
 #include <math.h>
 #endif
@@ -18,8 +18,8 @@
 #include <mruby/string.h>
 #include <mruby/class.h>
 
-#ifndef MRB_WITHOUT_FLOAT
-#ifdef MRB_USE_FLOAT
+#ifndef MRB_NO_FLOAT
+#ifdef MRB_USE_FLOAT32
 #define trunc(f) truncf(f)
 #define floor(f) floorf(f)
 #define ceil(f) ceilf(f)
@@ -30,13 +30,13 @@
 #endif
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_float
 mrb_to_flo(mrb_state *mrb, mrb_value val)
 {
   switch (mrb_type(val)) {
-  case MRB_TT_FIXNUM:
-    return (mrb_float)mrb_fixnum(val);
+  case MRB_TT_INTEGER:
+    return (mrb_float)mrb_integer(val);
   case MRB_TT_FLOAT:
     break;
   default:
@@ -44,15 +44,6 @@ mrb_to_flo(mrb_state *mrb, mrb_value val)
   }
   return mrb_float(val);
 }
-
-MRB_API mrb_value
-mrb_int_value(mrb_state *mrb, mrb_float f)
-{
-  if (FIXABLE_FLOAT(f)) {
-    return mrb_fixnum_value((mrb_int)f);
-  }
-  return mrb_float_value(mrb, f);
-}
 #endif
 
 /*
@@ -65,80 +56,125 @@ mrb_int_value(mrb_state *mrb, mrb_float f)
  *    2.0**3      #=> 8.0
  */
 static mrb_value
-integral_pow(mrb_state *mrb, mrb_value x)
+int_pow(mrb_state *mrb, mrb_value x)
 {
-  mrb_value y = mrb_get_arg1(mrb);
-#ifndef MRB_WITHOUT_FLOAT
-  mrb_float d;
-#endif
+  mrb_int base = mrb_int(mrb, x);
+  mrb_int exp;
+#ifndef MRB_NO_FLOAT
+  mrb_value y;
+  mrb_float z;
 
-  if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) {
-    /* try ipow() */
-    mrb_int base = mrb_fixnum(x);
-    mrb_int exp = mrb_fixnum(y);
-    mrb_int result = 1;
-
-    if (exp < 0)
-#ifdef MRB_WITHOUT_FLOAT
-      return mrb_fixnum_value(0);
+  mrb_get_args(mrb, "o", &y);
+  if (!mrb_integer_p(y)) {
+    mrb_get_args(mrb, "f", &z);
+    z = pow((mrb_float)base, z);
+    return mrb_float_value(mrb, z);
+  }
+  else {
+    mrb_get_args(mrb, "i", &exp);
+    z = pow((double)base, (double)exp);
+    if (exp < 0 || z < (mrb_float)MRB_INT_MIN || (mrb_float)MRB_INT_MAX < z) {
+      return mrb_float_value(mrb, z);
+    }
+  }
+  return mrb_int_value(mrb, (mrb_int)z);
 #else
-      goto float_pow;
-#endif
-    for (;;) {
-      if (exp & 1) {
-        if (mrb_int_mul_overflow(result, base, &result)) {
-#ifndef MRB_WITHOUT_FLOAT
-          goto float_pow;
-#endif
-        }
-      }
-      exp >>= 1;
-      if (exp == 0) break;
-      if (mrb_int_mul_overflow(base, base, &base)) {
-#ifndef MRB_WITHOUT_FLOAT
-        goto float_pow;
-#endif
+  mrb_int result = 1;
+
+  mrb_get_args(mrb, "i", &exp);
+  if (exp < 0) {
+    return mrb_fixnum_value(0);
+  }
+  for (;;) {
+    if (exp & 1) {
+      if (mrb_int_mul_overflow(result, base, &result)) {
+        mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division");
       }
     }
-    return mrb_fixnum_value(result);
+    exp >>= 1;
+    if (exp == 0) break;
+    if (mrb_int_mul_overflow(base, base, &base)) {
+      mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division");
+    }
   }
-#ifdef MRB_WITHOUT_FLOAT
-  mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
-#else
- float_pow:
-  d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
-  return mrb_float_value(mrb, d);
+  return mrb_int_value(mrb, result);
 #endif
 }
 
-static mrb_value
-integral_idiv(mrb_state *mrb, mrb_value x)
-{
-#ifdef MRB_WITHOUT_FLOAT
-  mrb_value y = mrb_get_arg1(mrb);
 
-  if (!mrb_fixnum_p(y)) {
-    mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
+mrb_int
+mrb_num_div_int(mrb_state *mrb, mrb_int x, mrb_int y)
+{
+  if (y == 0) {
+    mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
   }
-  return mrb_fixnum_value(mrb_fixnum(x) / mrb_fixnum(y));
-#else
-  mrb_float y;
+  else if(x == MRB_INT_MIN && y == -1) {
+    mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in division");
+  }
+  else {
+    mrb_int div, mod;
 
-  mrb_get_args(mrb, "f", &y);
-  return mrb_int_value(mrb, mrb_to_flo(mrb, x) / y);
-#endif
+    if (y < 0) {
+      if (x < 0)
+        div = -x / -y;
+      else
+        div = - (x / -y);
+    }
+    else {
+      if (x < 0)
+        div = - (-x / y);
+      else
+        div = x / y;
+    }
+    mod = x - div * y;
+    if ((mod < 0 && y > 0) || (mod > 0 && y < 0)) {
+      div -= 1;
+    }
+    return div;
+  }
+  /* not reached */
+  return 0;
 }
 
 /* 15.2.8.3.4  */
 /* 15.2.9.3.4  */
 /*
  * call-seq:
- *   num / other  ->  num
+ *   int / other  ->  int
  *
  * Performs division: the class of the resulting object depends on
  * the class of <code>num</code> and on the magnitude of the
  * result.
  */
+static mrb_value
+int_div(mrb_state *mrb, mrb_value xv)
+{
+#ifndef MRB_NO_FLOAT
+  mrb_value yv;
+
+  mrb_get_args(mrb, "o", &yv);
+  if (mrb_float_p(yv)) {
+    double d = mrb_integer(xv)/mrb_float(yv);
+#ifdef MRB_INT32
+    if (MRB_INT_MIN <= d && d <= MRB_INT_MAX)
+      return mrb_int_value(mrb, (mrb_int)d);
+    return mrb_float_value(mrb, d);
+#else
+    return mrb_int_value(mrb, (mrb_int)d);
+#endif
+  }
+  else
+#endif
+  {
+    mrb_int y;
+
+    mrb_get_args(mrb, "i", &y);
+    if (y == 0) {
+      mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero");
+    }
+    return mrb_int_value(mrb, mrb_integer(xv) / y);
+  }
+}
 
 /* 15.2.9.3.19(x) */
 /*
@@ -149,42 +185,32 @@ integral_idiv(mrb_state *mrb, mrb_value x)
  */
 
 static mrb_value
-integral_div(mrb_state *mrb, mrb_value xv)
+int_quo(mrb_state *mrb, mrb_value xv)
 {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_int y;
 
   mrb_get_args(mrb, "i", &y);
   if (y == 0) {
-    mrb_raise(mrb, E_RUNTIME_ERROR, "devided by zero");
+    mrb_raise(mrb, E_ZERODIV_ERROR, "devided by zero");
   }
   return mrb_fixnum_value(mrb_fixnum(xv) / y);
 #else
-  mrb_float x, y;
+  mrb_float y;
 
   mrb_get_args(mrb, "f", &y);
-  x = mrb_to_flo(mrb, xv);
-  if (y == 0) {
-    if (x < 0)
-      y = -INFINITY;
-    else if (x > 0)
-      y = INFINITY;
-    else /* if (x == 0) */
-      y = NAN;
-    return mrb_float_value(mrb, y);
-  }
-  return mrb_float_value(mrb, x / y);
+  return mrb_float_value(mrb, (mrb_float)mrb_integer(xv) / y);
 #endif
 }
 
 static mrb_value
-integral_coerce_step_counter(mrb_state *mrb, mrb_value self)
+coerce_step_counter(mrb_state *mrb, mrb_value self)
 {
   mrb_value num, step;
 
   mrb_get_args(mrb, "oo", &num, &step);
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   if (mrb_float_p(self) || mrb_float_p(num) || mrb_float_p(step)) {
     return mrb_Float(mrb, self);
   }
@@ -193,7 +219,7 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self)
   return self;
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /********************************************************************
  *
  * Document-class: Float
@@ -203,19 +229,59 @@ integral_coerce_step_counter(mrb_state *mrb, mrb_value self)
  *  representation.
  */
 
-/* 15.2.9.3.16(x) */
-/*
- *  call-seq:
- *     flt.to_s  ->  string
- *
- *  Returns a string containing a representation of self. As well as a
- *  fixed or exponential form of the number, the call may return
- *  "<code>NaN</code>", "<code>Infinity</code>", and
- *  "<code>-Infinity</code>".
- */
+static mrb_value
+flo_pow(mrb_state *mrb, mrb_value x)
+{
+  mrb_value y = mrb_get_arg1(mrb);
+  mrb_float d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
+  return mrb_float_value(mrb, d);
+}
 
 static mrb_value
-flo_to_s(mrb_state *mrb, mrb_value flt)
+flo_idiv(mrb_state *mrb, mrb_value x)
+{
+  mrb_float y;
+
+  mrb_get_args(mrb, "f", &y);
+  y = mrb_to_flo(mrb, x) / y;
+#ifdef MRB_INT32
+  if (MRB_INT_MIN <= y && y <= MRB_INT_MAX)
+    return mrb_int_value(mrb, (mrb_int)y);
+  return mrb_float_value(mrb, y);
+#else
+  return mrb_int_value(mrb, (mrb_int)y);
+#endif
+}
+
+mrb_float
+mrb_num_div_flo(mrb_state *mrb, mrb_float x, mrb_float y)
+{
+  mrb_float f;
+
+  if (y == 0) {
+    if (x > 0) f = INFINITY;
+    else if (x < 0) f = -INFINITY;
+    else /* if (x == 0) */ f = NAN;
+  }
+  else {
+    f = x / y;
+  }
+  return f;
+}
+
+static mrb_value
+flo_div(mrb_state *mrb, mrb_value xv)
+{
+  mrb_float x, y;
+
+  x = mrb_float(xv);
+  mrb_get_args(mrb, "f", &y);
+  x = mrb_num_div_flo(mrb, x, y);
+  return mrb_float_value(mrb, x);
+}
+
+static mrb_value
+flo_to_str(mrb_state *mrb, mrb_value flt, mrb_bool add_dot_zero)
 {
   mrb_float f = mrb_float(flt);
   mrb_value str;
@@ -258,6 +324,9 @@ flo_to_s(mrb_state *mrb, mrb_value flt)
       str = mrb_float_to_str(mrb, flt, fmt);
       goto insert_dot_zero;
     }
+    else if (add_dot_zero) {
+      mrb_str_cat(mrb, str, ".0", 2);
+    }
 
     goto exit;
   }
@@ -267,6 +336,49 @@ flo_to_s(mrb_state *mrb, mrb_value flt)
   return str;
 }
 
+/* 15.2.9.3.16(x) */
+/*
+ *  call-seq:
+ *     flt.to_s  ->  string
+ *
+ *  Returns a string containing a representation of self. As well as a
+ *  fixed or exponential form of the number, the call may return
+ *  "<code>NaN</code>", "<code>Infinity</code>", and
+ *  "<code>-Infinity</code>".
+ *
+ *  Trailing <code>.0</code> is removed.
+ *
+ *     3.0.to_s   #=> 3
+ *     3.25.to_s  #=> 3.25
+ */
+
+static mrb_value
+flo_to_s(mrb_state *mrb, mrb_value flt)
+{
+  return flo_to_str(mrb, flt, FALSE);
+}
+
+/*
+ *  call-seq:
+ *     flt.inspect  ->  string
+ *
+ *  Returns a string containing a representation of self. As well as a
+ *  fixed or exponential form of the number, the call may return
+ *  "<code>NaN</code>", "<code>Infinity</code>", and
+ *  "<code>-Infinity</code>".
+ *
+ *  Trailing <code>.0</code> is added.
+ *
+ *     3.0.to_s   #=> 3.0
+ *     3.25.to_s  #=> 3.25
+ */
+
+static mrb_value
+flo_inspect(mrb_state *mrb, mrb_value flt)
+{
+  return flo_to_str(mrb, flt, TRUE);
+}
+
 /* 15.2.9.3.2  */
 /*
  * call-seq:
@@ -378,15 +490,15 @@ flo_mod(mrb_state *mrb, mrb_value x)
  *     (1.0).eql?(1.0)   #=> true
  */
 static mrb_value
-fix_eql(mrb_state *mrb, mrb_value x)
+int_eql(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
-  if (!mrb_fixnum_p(y)) return mrb_false_value();
-  return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y));
+  if (!mrb_integer_p(y)) return mrb_false_value();
+  return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static mrb_value
 flo_eql(mrb_state *mrb, mrb_value x)
 {
@@ -415,8 +527,8 @@ flo_eq(mrb_state *mrb, mrb_value x)
   mrb_value y = mrb_get_arg1(mrb);
 
   switch (mrb_type(y)) {
-  case MRB_TT_FIXNUM:
-    return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_fixnum(y));
+  case MRB_TT_INTEGER:
+    return mrb_bool_value(mrb_float(x) == (mrb_float)mrb_integer(y));
   case MRB_TT_FLOAT:
     return mrb_bool_value(mrb_float(x) == mrb_float(y));
   default:
@@ -428,8 +540,8 @@ static int64_t
 value_int64(mrb_state *mrb, mrb_value x)
 {
   switch (mrb_type(x)) {
-  case MRB_TT_FIXNUM:
-    return (int64_t)mrb_fixnum(x);
+  case MRB_TT_INTEGER:
+    return (int64_t)mrb_integer(x);
   case MRB_TT_FLOAT:
     return (int64_t)mrb_float(x);
   default:
@@ -525,7 +637,7 @@ flo_shift(mrb_state *mrb, mrb_value x, mrb_int width)
       val *= 2;
     }
   }
-  return mrb_int_value(mrb, val);
+  return mrb_int_value(mrb, (mrb_int)val);
 }
 
 static mrb_value
@@ -631,7 +743,7 @@ flo_floor(mrb_state *mrb, mrb_value num)
   mrb_float f = floor(mrb_float(num));
 
   mrb_check_num_exact(mrb, f);
-  return mrb_int_value(mrb, f);
+  return mrb_int_value(mrb, (mrb_int)f);
 }
 
 /* 15.2.9.3.8  */
@@ -654,7 +766,7 @@ flo_ceil(mrb_state *mrb, mrb_value num)
   mrb_float f = ceil(mrb_float(num));
 
   mrb_check_num_exact(mrb, f);
-  return mrb_int_value(mrb, f);
+  return mrb_int_value(mrb, (mrb_int)f);
 }
 
 /* 15.2.9.3.12 */
@@ -736,7 +848,7 @@ flo_round(mrb_state *mrb, mrb_value num)
     if (!isfinite(number)) return num;
     return mrb_float_value(mrb, number);
   }
-  return mrb_int_value(mrb, number);
+  return mrb_int_value(mrb, (mrb_int)number);
 }
 
 /* 15.2.9.3.14 */
@@ -758,7 +870,7 @@ flo_truncate(mrb_state *mrb, mrb_value num)
   if (f < 0.0) f = ceil(f);
 
   mrb_check_num_exact(mrb, f);
-  return mrb_int_value(mrb, f);
+  return mrb_int_value(mrb, (mrb_int)f);
 }
 
 static mrb_value
@@ -771,8 +883,7 @@ flo_nan_p(mrb_state *mrb, mrb_value num)
 /*
  * Document-class: Integer
  *
- *  <code>Integer</code> is the basis for the two concrete classes that
- *  hold whole numbers, <code>Bignum</code> and <code>Fixnum</code>.
+ *  <code>Integer</code> is hold whole numbers.
  *
  */
 
@@ -796,20 +907,20 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
 {
   mrb_int a;
 
-  a = mrb_fixnum(x);
-  if (mrb_fixnum_p(y)) {
+  a = mrb_integer(x);
+  if (mrb_integer_p(y)) {
     mrb_int b, c;
 
     if (a == 0) return x;
-    b = mrb_fixnum(y);
+    b = mrb_integer(y);
     if (mrb_int_mul_overflow(a, b, &c)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b);
 #endif
     }
     return mrb_fixnum_value(c);
   }
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
 #else
   return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y));
@@ -819,10 +930,10 @@ fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
 MRB_API mrb_value
 mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y)
 {
-  if (mrb_fixnum_p(x)) {
+  if (mrb_integer_p(x)) {
     return fixnum_mul(mrb, x, y);
   }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   if (mrb_float_p(x)) {
     return mrb_float_value(mrb, mrb_float(x) * mrb_to_flo(mrb, y));
   }
@@ -842,7 +953,7 @@ mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y)
  */
 
 static mrb_value
-fix_mul(mrb_state *mrb, mrb_value x)
+int_mul(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
@@ -888,29 +999,22 @@ fixdivmod(mrb_state *mrb, mrb_int x, mrb_int y, mrb_int *divp, mrb_int *modp)
  */
 
 static mrb_value
-fix_mod(mrb_state *mrb, mrb_value x)
+int_mod(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
   mrb_int a, b;
 
-  a = mrb_fixnum(x);
-  if (mrb_fixnum_p(y) && a != MRB_INT_MIN && (b=mrb_fixnum(y)) != MRB_INT_MIN) {
+  a = mrb_integer(x);
+  if (mrb_integer_p(y) && a != MRB_INT_MIN && (b=mrb_integer(y)) != MRB_INT_MIN) {
     mrb_int mod;
 
     if (b == 0) {
-#ifdef MRB_WITHOUT_FLOAT
-      /* ZeroDivisionError */
-      return mrb_fixnum_value(0);
-#else
-      if (a > 0) return mrb_float_value(mrb, INFINITY);
-      if (a < 0) return mrb_float_value(mrb, INFINITY);
-      return mrb_float_value(mrb, NAN);
-#endif
+      mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
     }
     fixdivmod(mrb, a, b, NULL, &mod);
     return mrb_fixnum_value(mod);
   }
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
 #else
   else {
@@ -929,42 +1033,35 @@ fix_mod(mrb_state *mrb, mrb_value x)
  *  See <code>Numeric#divmod</code>.
  */
 static mrb_value
-fix_divmod(mrb_state *mrb, mrb_value x)
+int_divmod(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
-  if (mrb_fixnum_p(y)) {
+  if (mrb_integer_p(y)) {
     mrb_int div, mod;
 
-    if (mrb_fixnum(y) == 0) {
-#ifdef MRB_WITHOUT_FLOAT
-      return mrb_assoc_new(mrb, mrb_fixnum_value(0), mrb_fixnum_value(0));
-#else
-      return mrb_assoc_new(mrb, ((mrb_fixnum(x) == 0) ?
-                                 mrb_float_value(mrb, NAN):
-                                 mrb_float_value(mrb, INFINITY)),
-                           mrb_float_value(mrb, NAN));
-#endif
+    if (mrb_integer(y) == 0) {
+      mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0");
     }
-    fixdivmod(mrb, mrb_fixnum(x), mrb_fixnum(y), &div, &mod);
-    return mrb_assoc_new(mrb, mrb_fixnum_value(div), mrb_fixnum_value(mod));
+    fixdivmod(mrb, mrb_integer(x), mrb_integer(y), &div, &mod);
+    return mrb_assoc_new(mrb, mrb_int_value(mrb, div), mrb_int_value(mrb, mod));
   }
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
 #else
   else {
     mrb_float div, mod;
     mrb_value a, b;
 
-    flodivmod(mrb, (mrb_float)mrb_fixnum(x), mrb_to_flo(mrb, y), &div, &mod);
-    a = mrb_int_value(mrb, div);
+    flodivmod(mrb, (mrb_float)mrb_integer(x), mrb_to_flo(mrb, y), &div, &mod);
+    a = mrb_int_value(mrb, (mrb_int)div);
     b = mrb_float_value(mrb, mod);
     return mrb_assoc_new(mrb, a, b);
   }
 #endif
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static mrb_value
 flo_divmod(mrb_state *mrb, mrb_value x)
 {
@@ -973,7 +1070,7 @@ flo_divmod(mrb_state *mrb, mrb_value x)
   mrb_value a, b;
 
   flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod);
-  a = mrb_int_value(mrb, div);
+  a = mrb_int_value(mrb, (mrb_int)div);
   b = mrb_float_value(mrb, mod);
   return mrb_assoc_new(mrb, a, b);
 }
@@ -992,16 +1089,16 @@ flo_divmod(mrb_state *mrb, mrb_value x)
  */
 
 static mrb_value
-fix_equal(mrb_state *mrb, mrb_value x)
+int_equal(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
   switch (mrb_type(y)) {
-  case MRB_TT_FIXNUM:
-    return mrb_bool_value(mrb_fixnum(x) == mrb_fixnum(y));
-#ifndef MRB_WITHOUT_FLOAT
+  case MRB_TT_INTEGER:
+    return mrb_bool_value(mrb_integer(x) == mrb_integer(y));
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
-    return mrb_bool_value((mrb_float)mrb_fixnum(x) == mrb_float(y));
+    return mrb_bool_value((mrb_float)mrb_integer(x) == mrb_float(y));
 #endif
   default:
     return mrb_false_value();
@@ -1020,24 +1117,24 @@ fix_equal(mrb_state *mrb, mrb_value x)
  */
 
 static mrb_value
-fix_rev(mrb_state *mrb, mrb_value num)
+int_rev(mrb_state *mrb, mrb_value num)
 {
-  mrb_int val = mrb_fixnum(num);
+  mrb_int val = mrb_integer(num);
 
-  return mrb_fixnum_value(~val);
+  return mrb_int_value(mrb, ~val);
 }
 
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
 #define bit_op(x,y,op1,op2) do {\
-  return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\
+  return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y)));\
 } while(0)
 #else
 static mrb_value flo_and(mrb_state *mrb, mrb_value x);
 static mrb_value flo_or(mrb_state *mrb, mrb_value x);
 static mrb_value flo_xor(mrb_state *mrb, mrb_value x);
 #define bit_op(x,y,op1,op2) do {\
-  if (mrb_fixnum_p(y)) return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\
-  return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_fixnum(x)));\
+  if (mrb_integer_p(y)) return mrb_int_value(mrb, (mrb_integer(x) op2 mrb_integer(y))); \
+  return flo_ ## op1(mrb, mrb_float_value(mrb, (mrb_float)mrb_integer(x)));\
 } while(0)
 #endif
 
@@ -1050,7 +1147,7 @@ static mrb_value flo_xor(mrb_state *mrb, mrb_value x);
  */
 
 static mrb_value
-fix_and(mrb_state *mrb, mrb_value x)
+int_and(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
@@ -1066,7 +1163,7 @@ fix_and(mrb_state *mrb, mrb_value x)
  */
 
 static mrb_value
-fix_or(mrb_state *mrb, mrb_value x)
+int_or(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
@@ -1082,7 +1179,7 @@ fix_or(mrb_state *mrb, mrb_value x)
  */
 
 static mrb_value
-fix_xor(mrb_state *mrb, mrb_value x)
+int_xor(mrb_state *mrb, mrb_value x)
 {
   mrb_value y = mrb_get_arg1(mrb);
 
@@ -1095,7 +1192,7 @@ static mrb_value
 lshift(mrb_state *mrb, mrb_int val, mrb_int width)
 {
   if (width < 0) {              /* mrb_int overflow */
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
     return mrb_fixnum_value(0);
 #else
     return mrb_float_value(mrb, INFINITY);
@@ -1104,27 +1201,27 @@ lshift(mrb_state *mrb, mrb_int val, mrb_int width)
   if (val > 0) {
     if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
         (val   > (MRB_INT_MAX >> width))) {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
       return mrb_fixnum_value(-1);
 #else
       goto bit_overflow;
 #endif
     }
-    return mrb_fixnum_value(val << width);
+    return mrb_int_value(mrb, val << width);
   }
   else {
     if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
         (val   <= (MRB_INT_MIN >> width))) {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
       return mrb_fixnum_value(0);
 #else
       goto bit_overflow;
 #endif
     }
-    return mrb_fixnum_value(val * ((mrb_int)1 << width));
+    return mrb_int_value(mrb, (val * ((mrb_int)1 << width)));
   }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 bit_overflow:
   {
     mrb_float f = (mrb_float)val;
@@ -1137,7 +1234,7 @@ bit_overflow:
 }
 
 static mrb_value
-rshift(mrb_int val, mrb_int width)
+rshift(mrb_state *mrb, mrb_int val, mrb_int width)
 {
   if (width < 0) {              /* mrb_int overflow */
     return mrb_fixnum_value(0);
@@ -1148,7 +1245,7 @@ rshift(mrb_int val, mrb_int width)
     }
     return mrb_fixnum_value(0);
   }
-  return mrb_fixnum_value(val >> width);
+  return mrb_int_value(mrb, val >> width);
 }
 
 /* 15.2.8.3.12 */
@@ -1160,7 +1257,7 @@ rshift(mrb_int val, mrb_int width)
  */
 
 static mrb_value
-fix_lshift(mrb_state *mrb, mrb_value x)
+int_lshift(mrb_state *mrb, mrb_value x)
 {
   mrb_int width, val;
 
@@ -1168,10 +1265,10 @@ fix_lshift(mrb_state *mrb, mrb_value x)
   if (width == 0) {
     return x;
   }
-  val = mrb_fixnum(x);
+  val = mrb_integer(x);
   if (val == 0) return x;
   if (width < 0) {
-    return rshift(val, -width);
+    return rshift(mrb, val, -width);
   }
   return lshift(mrb, val, width);
 }
@@ -1185,7 +1282,7 @@ fix_lshift(mrb_state *mrb, mrb_value x)
  */
 
 static mrb_value
-fix_rshift(mrb_state *mrb, mrb_value x)
+int_rshift(mrb_state *mrb, mrb_value x)
 {
   mrb_int width, val;
 
@@ -1193,12 +1290,12 @@ fix_rshift(mrb_state *mrb, mrb_value x)
   if (width == 0) {
     return x;
   }
-  val = mrb_fixnum(x);
+  val = mrb_integer(x);
   if (val == 0) return x;
   if (width < 0) {
     return lshift(mrb, val, -width);
   }
-  return rshift(val, width);
+  return rshift(mrb, val, width);
 }
 
 /* 15.2.8.3.23 */
@@ -1210,11 +1307,11 @@ fix_rshift(mrb_state *mrb, mrb_value x)
  *
  */
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static mrb_value
-fix_to_f(mrb_state *mrb, mrb_value num)
+int_to_f(mrb_state *mrb, mrb_value num)
 {
-  return mrb_float_value(mrb, (mrb_float)mrb_fixnum(num));
+  return mrb_float_value(mrb, (mrb_float)mrb_integer(num));
 }
 
 /*
@@ -1251,7 +1348,7 @@ mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x)
       mrb_raisef(mrb, E_RANGE_ERROR, "number (%v) too big for integer", x);
     }
   }
-  return mrb_fixnum_value(z);
+  return mrb_int_value(mrb, z);
 }
 #endif
 
@@ -1260,20 +1357,20 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y)
 {
   mrb_int a;
 
-  a = mrb_fixnum(x);
-  if (mrb_fixnum_p(y)) {
+  a = mrb_integer(x);
+  if (mrb_integer_p(y)) {
     mrb_int b, c;
 
     if (a == 0) return y;
-    b = mrb_fixnum(y);
+    b = mrb_integer(y);
     if (mrb_int_add_overflow(a, b, &c)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       return mrb_float_value(mrb, (mrb_float)a + (mrb_float)b);
 #endif
     }
-    return mrb_fixnum_value(c);
+    return mrb_int_value(mrb, c);
   }
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
 #else
   return mrb_float_value(mrb, (mrb_float)a + mrb_to_flo(mrb, y));
@@ -1283,10 +1380,10 @@ fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y)
 MRB_API mrb_value
 mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y)
 {
-  if (mrb_fixnum_p(x)) {
+  if (mrb_integer_p(x)) {
     return fixnum_plus(mrb, x, y);
   }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   if (mrb_float_p(x)) {
     return mrb_float_value(mrb, mrb_float(x) + mrb_to_flo(mrb, y));
   }
@@ -1305,7 +1402,7 @@ mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y)
  * result.
  */
 static mrb_value
-fix_plus(mrb_state *mrb, mrb_value self)
+int_plus(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
 
@@ -1317,19 +1414,19 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y)
 {
   mrb_int a;
 
-  a = mrb_fixnum(x);
-  if (mrb_fixnum_p(y)) {
+  a = mrb_integer(x);
+  if (mrb_integer_p(y)) {
     mrb_int b, c;
 
-    b = mrb_fixnum(y);
+    b = mrb_integer(y);
     if (mrb_int_sub_overflow(a, b, &c)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       return mrb_float_value(mrb, (mrb_float)a - (mrb_float)b);
 #endif
     }
-    return mrb_fixnum_value(c);
+    return mrb_int_value(mrb, c);
   }
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_raise(mrb, E_TYPE_ERROR, "non fixnum value");
 #else
   return mrb_float_value(mrb, (mrb_float)a - mrb_to_flo(mrb, y));
@@ -1339,10 +1436,10 @@ fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y)
 MRB_API mrb_value
 mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y)
 {
-  if (mrb_fixnum_p(x)) {
+  if (mrb_integer_p(x)) {
     return fixnum_minus(mrb, x, y);
   }
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   if (mrb_float_p(x)) {
     return mrb_float_value(mrb, mrb_float(x) - mrb_to_flo(mrb, y));
   }
@@ -1362,7 +1459,7 @@ mrb_num_minus(mrb_state *mrb, mrb_value x, mrb_value y)
  * result.
  */
 static mrb_value
-fix_minus(mrb_state *mrb, mrb_value self)
+int_minus(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
 
@@ -1375,7 +1472,7 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base)
 {
   char buf[MRB_INT_BIT+1];
   char *b = buf + sizeof buf;
-  mrb_int val = mrb_fixnum(x);
+  mrb_int val = mrb_integer(x);
   mrb_value str;
 
   if (base < 2 || 36 < base) {
@@ -1419,7 +1516,7 @@ mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base)
  *
  */
 static mrb_value
-fix_to_s(mrb_state *mrb, mrb_value self)
+int_to_s(mrb_state *mrb, mrb_value self)
 {
   mrb_int base = 10;
 
@@ -1431,26 +1528,26 @@ fix_to_s(mrb_state *mrb, mrb_value self)
 static mrb_int
 cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2)
 {
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_int x, y;
 #else
   mrb_float x, y;
 #endif
 
-#ifdef MRB_WITHOUT_FLOAT
-  x = mrb_fixnum(v1);
+#ifdef MRB_NO_FLOAT
+  x = mrb_integer(v1);
 #else
   x = mrb_to_flo(mrb, v1);
 #endif
   switch (mrb_type(v2)) {
-  case MRB_TT_FIXNUM:
-#ifdef MRB_WITHOUT_FLOAT
-    y = mrb_fixnum(v2);
+  case MRB_TT_INTEGER:
+#ifdef MRB_NO_FLOAT
+    y = mrb_integer(v2);
 #else
-    y = (mrb_float)mrb_fixnum(v2);
+    y = (mrb_float)mrb_integer(v2);
 #endif
     break;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
     y = mrb_float(v2);
     break;
@@ -1480,7 +1577,7 @@ cmpnum(mrb_state *mrb, mrb_value v1, mrb_value v2)
  *  not comparable, it returns nil instead of raising an exception.
  */
 static mrb_value
-integral_cmp(mrb_state *mrb, mrb_value self)
+num_cmp(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1497,7 +1594,7 @@ cmperr(mrb_state *mrb, mrb_value v1, mrb_value v2)
 }
 
 static mrb_value
-integral_lt(mrb_state *mrb, mrb_value self)
+num_lt(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1509,7 +1606,7 @@ integral_lt(mrb_state *mrb, mrb_value self)
 }
 
 static mrb_value
-integral_le(mrb_state *mrb, mrb_value self)
+num_le(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1521,7 +1618,7 @@ integral_le(mrb_state *mrb, mrb_value self)
 }
 
 static mrb_value
-integral_gt(mrb_state *mrb, mrb_value self)
+num_gt(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1533,7 +1630,7 @@ integral_gt(mrb_state *mrb, mrb_value self)
 }
 
 static mrb_value
-integral_ge(mrb_state *mrb, mrb_value self)
+num_ge(mrb_state *mrb, mrb_value self)
 {
   mrb_value other = mrb_get_arg1(mrb);
   mrb_int n;
@@ -1550,7 +1647,7 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
   mrb_value v;
 
   switch (mrb_type(obj1)) {
-  case MRB_TT_FIXNUM:
+  case MRB_TT_INTEGER:
   case MRB_TT_FLOAT:
     return cmpnum(mrb, obj1, obj2);
   case MRB_TT_STRING:
@@ -1558,10 +1655,10 @@ mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
       return -2;
     return mrb_str_cmp(mrb, obj1, obj2);
   default:
-    v = mrb_funcall(mrb, obj1, "<=>", 1, obj2);
-    if (mrb_nil_p(v) || !mrb_fixnum_p(v))
+    v = mrb_funcall_id(mrb, obj1, MRB_SYM(cmp), 1, obj2);
+    if (mrb_nil_p(v) || !mrb_integer_p(v))
       return -2;
-    return mrb_fixnum(v);
+    return mrb_integer(v);
   }
 }
 
@@ -1585,7 +1682,7 @@ num_infinite_p(mrb_state *mrb, mrb_value self)
  * Returns a new float which is the sum of <code>float</code>
  * and <code>other</code>.
  */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static mrb_value
 flo_plus(mrb_state *mrb, mrb_value x)
 {
@@ -1599,72 +1696,81 @@ flo_plus(mrb_state *mrb, mrb_value x)
 void
 mrb_init_numeric(mrb_state *mrb)
 {
-  struct RClass *numeric, *integer, *fixnum, *integral;
-#ifndef MRB_WITHOUT_FLOAT
+  struct RClass *numeric, *integer;
+#ifndef MRB_NO_FLOAT
   struct RClass *fl;
 #endif
 
-  integral = mrb_define_module(mrb, "Integral");
-  mrb_define_method(mrb, integral,"**",       integral_pow,    MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,"/",        integral_div,    MRB_ARGS_REQ(1)); /* 15.2.{8,9}.3.6  */
-  mrb_define_method(mrb, integral,"quo",      integral_div,    MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
-  mrb_define_method(mrb, integral,"div",      integral_idiv,   MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,"<=>",      integral_cmp,    MRB_ARGS_REQ(1)); /* 15.2.{8,9}.3.1  */
-  mrb_define_method(mrb, integral,"<",        integral_lt,     MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,"<=",       integral_le,     MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,">",        integral_gt,     MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,">=",       integral_ge,     MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, integral,"__coerce_step_counter", integral_coerce_step_counter, MRB_ARGS_REQ(2));
-
   /* Numeric Class */
   numeric = mrb_define_class(mrb, "Numeric",  mrb->object_class);                /* 15.2.7 */
   mrb_define_method(mrb, numeric, "finite?",  num_finite_p,    MRB_ARGS_NONE());
   mrb_define_method(mrb, numeric, "infinite?",num_infinite_p,  MRB_ARGS_NONE());
 
   /* Integer Class */
-  integer = mrb_define_class(mrb, "Integer",  numeric);                          /* 15.2.8 */
-  MRB_SET_INSTANCE_TT(integer, MRB_TT_FIXNUM);
+  mrb->integer_class = integer = mrb_define_class(mrb, "Integer",  numeric);     /* 15.2.8 */
+  MRB_SET_INSTANCE_TT(integer, MRB_TT_INTEGER);
   mrb_undef_class_method(mrb, integer, "new");
+  mrb_define_method(mrb, integer, "**",       int_pow,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, "/",        int_div,         MRB_ARGS_REQ(1)); /* 15.2.8.3.6  */
+  mrb_define_method(mrb, integer, "quo",      int_quo,         MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
+  mrb_define_method(mrb, integer, "div",      int_div,        MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, "<=>",      num_cmp,         MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
+  mrb_define_method(mrb, integer, "<",        num_lt,          MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, "<=",       num_le,          MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, ">",        num_gt,          MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, integer, ">=",       num_ge,          MRB_ARGS_REQ(1));
+
   mrb_define_method(mrb, integer, "to_i",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.24 */
   mrb_define_method(mrb, integer, "to_int",   int_to_i,        MRB_ARGS_NONE());
-#ifndef MRB_WITHOUT_FLOAT
-  mrb_define_method(mrb, integer, "ceil",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.8 (x) */
-  mrb_define_method(mrb, integer, "floor",    int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.10 (x) */
-  mrb_define_method(mrb, integer, "round",    int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.12 (x) */
-  mrb_define_method(mrb, integer, "truncate", int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.15 (x) */
+#ifndef MRB_NO_FLOAT
+  mrb_define_method(mrb, integer, "ceil",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.14 */
+  mrb_define_method(mrb, integer, "floor",    int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.17 */
+  mrb_define_method(mrb, integer, "round",    int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.20 */
+  mrb_define_method(mrb, integer, "truncate", int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.26 */
 #endif
 
-  /* Fixnum Class */
-  mrb->fixnum_class = fixnum = mrb_define_class(mrb, "Fixnum", integer);
-  mrb_define_method(mrb, fixnum,  "+",        fix_plus,        MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
-  mrb_define_method(mrb, fixnum,  "-",        fix_minus,       MRB_ARGS_REQ(1)); /* 15.2.8.3.2  */
-  mrb_define_method(mrb, fixnum,  "*",        fix_mul,         MRB_ARGS_REQ(1)); /* 15.2.8.3.3  */
-  mrb_define_method(mrb, fixnum,  "%",        fix_mod,         MRB_ARGS_REQ(1)); /* 15.2.8.3.5  */
-  mrb_define_method(mrb, fixnum,  "==",       fix_equal,       MRB_ARGS_REQ(1)); /* 15.2.8.3.7  */
-  mrb_define_method(mrb, fixnum,  "~",        fix_rev,         MRB_ARGS_NONE()); /* 15.2.8.3.8  */
-  mrb_define_method(mrb, fixnum,  "&",        fix_and,         MRB_ARGS_REQ(1)); /* 15.2.8.3.9  */
-  mrb_define_method(mrb, fixnum,  "|",        fix_or,          MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
-  mrb_define_method(mrb, fixnum,  "^",        fix_xor,         MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
-  mrb_define_method(mrb, fixnum,  "<<",       fix_lshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
-  mrb_define_method(mrb, fixnum,  ">>",       fix_rshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
-  mrb_define_method(mrb, fixnum,  "eql?",     fix_eql,         MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
-#ifndef MRB_WITHOUT_FLOAT
-  mrb_define_method(mrb, fixnum,  "to_f",     fix_to_f,        MRB_ARGS_NONE()); /* 15.2.8.3.23 */
+  mrb_define_method(mrb, integer, "+",        int_plus,        MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */
+  mrb_define_method(mrb, integer, "-",        int_minus,       MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */
+  mrb_define_method(mrb, integer, "*",        int_mul,         MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */
+  mrb_define_method(mrb, integer, "%",        int_mod,         MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */
+  mrb_define_method(mrb, integer, "==",       int_equal,       MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */
+  mrb_define_method(mrb, integer, "~",        int_rev,         MRB_ARGS_NONE()); /* 15.2.8.3.8 */
+  mrb_define_method(mrb, integer, "&",        int_and,         MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */
+  mrb_define_method(mrb, integer, "|",        int_or,          MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
+  mrb_define_method(mrb, integer, "^",        int_xor,         MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
+  mrb_define_method(mrb, integer, "<<",       int_lshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
+  mrb_define_method(mrb, integer, ">>",       int_rshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
+  mrb_define_method(mrb, integer, "eql?",     int_eql,         MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
+#ifndef MRB_NO_FLOAT
+  mrb_define_method(mrb, integer, "to_f",     int_to_f,        MRB_ARGS_NONE()); /* 15.2.8.3.23 */
 #endif
-  mrb_define_method(mrb, fixnum,  "to_s",     fix_to_s,        MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */
-  mrb_define_method(mrb, fixnum,  "inspect",  fix_to_s,        MRB_ARGS_OPT(1));
-  mrb_define_method(mrb, fixnum,  "divmod",   fix_divmod,      MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
+  mrb_define_method(mrb, integer, "to_s",     int_to_s,        MRB_ARGS_OPT(1)); /* 15.2.8.3.25 */
+  mrb_define_method(mrb, integer, "inspect",  int_to_s,        MRB_ARGS_OPT(1));
+  mrb_define_method(mrb, integer, "divmod",   int_divmod,      MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
+  mrb_define_method(mrb, integer, "__coerce_step_counter", coerce_step_counter, MRB_ARGS_REQ(2));
 
-#ifndef MRB_WITHOUT_FLOAT
+  /* Fixnum Class for compatibility */
+  mrb_define_const(mrb, mrb->object_class, "Fixnum", mrb_obj_value(integer));
+
+#ifndef MRB_NO_FLOAT
   /* Float Class */
   mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric);                 /* 15.2.9 */
   MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT);
   mrb_undef_class_method(mrb,  fl, "new");
-  mrb_define_method(mrb, fl,      "+",         flo_plus,       MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
-  mrb_define_method(mrb, fl,      "-",         flo_minus,      MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
-  mrb_define_method(mrb, fl,      "*",         flo_mul,        MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
-  mrb_define_method(mrb, fl,      "%",         flo_mod,        MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
-  mrb_define_method(mrb, fl,      "==",        flo_eq,         MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
+  mrb_define_method(mrb, fl,      "**",        flo_pow,        MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      "/",         flo_div,        MRB_ARGS_REQ(1)); /* 15.2.9.3.6  */
+  mrb_define_method(mrb, fl,      "quo",       flo_div,        MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
+  mrb_define_method(mrb, fl,      "div",       flo_idiv,       MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      "+",         flo_plus,       MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
+  mrb_define_method(mrb, fl,      "-",         flo_minus,      MRB_ARGS_REQ(1)); /* 15.2.9.3.4  */
+  mrb_define_method(mrb, fl,      "*",         flo_mul,        MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
+  mrb_define_method(mrb, fl,      "%",         flo_mod,        MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
+  mrb_define_method(mrb, fl,      "<=>",       num_cmp,        MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
+  mrb_define_method(mrb, fl,      "<",         num_lt,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      "<=",        num_le,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      ">",         num_gt,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      ">=",        num_ge,         MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, fl,      "==",        flo_eq,         MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
   mrb_define_method(mrb, fl,      "~",         flo_rev,        MRB_ARGS_NONE());
   mrb_define_method(mrb, fl,      "&",         flo_and,        MRB_ARGS_REQ(1));
   mrb_define_method(mrb, fl,      "|",         flo_or,         MRB_ARGS_REQ(1));
@@ -1684,16 +1790,14 @@ mrb_init_numeric(mrb_state *mrb)
   mrb_define_method(mrb, fl,      "eql?",      flo_eql,        MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
 
   mrb_define_method(mrb, fl,      "to_s",      flo_to_s,       MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
-  mrb_define_method(mrb, fl,      "inspect",   flo_to_s,       MRB_ARGS_NONE());
+  mrb_define_method(mrb, fl,      "inspect",   flo_inspect,    MRB_ARGS_NONE());
   mrb_define_method(mrb, fl,      "nan?",      flo_nan_p,      MRB_ARGS_NONE());
 
 #ifdef INFINITY
-  mrb_define_const(mrb, fl, "INFINITY", mrb_float_value(mrb, INFINITY));
+  mrb_define_const_id(mrb, fl, MRB_SYM(INFINITY), mrb_float_value(mrb, INFINITY));
 #endif
 #ifdef NAN
-  mrb_define_const(mrb, fl, "NAN", mrb_float_value(mrb, NAN));
+  mrb_define_const_id(mrb, fl, MRB_SYM(NAN), mrb_float_value(mrb, NAN));
 #endif
-
-  mrb_include_module(mrb, fl, integral);
 #endif
 }
diff --git a/src/object.c b/src/object.c
index 7257f402d..aaab4022d 100644
--- a/src/object.c
+++ b/src/object.c
@@ -19,12 +19,12 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
     return TRUE;
 
   case MRB_TT_FALSE:
-  case MRB_TT_FIXNUM:
-    return (mrb_fixnum(v1) == mrb_fixnum(v2));
+  case MRB_TT_INTEGER:
+    return (mrb_integer(v1) == mrb_integer(v2));
   case MRB_TT_SYMBOL:
     return (mrb_symbol(v1) == mrb_symbol(v2));
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   case MRB_TT_FLOAT:
     return (mrb_float(v1) == mrb_float(v2));
 #endif
@@ -47,18 +47,18 @@ mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
   mrb_value result;
 
   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   /* value mixing with integer and float */
-  if (mrb_fixnum_p(obj1)) {
-    if (mrb_float_p(obj2) && (mrb_float)mrb_fixnum(obj1) == mrb_float(obj2))
+  if (mrb_integer_p(obj1)) {
+    if (mrb_float_p(obj2) && (mrb_float)mrb_integer(obj1) == mrb_float(obj2))
       return TRUE;
   }
   else if (mrb_float_p(obj1)) {
-    if (mrb_fixnum_p(obj2) && mrb_float(obj1) == (mrb_float)mrb_fixnum(obj2))
+    if (mrb_integer_p(obj2) && mrb_float(obj1) == (mrb_float)mrb_integer(obj2))
       return TRUE;
   }
 #endif
-  result = mrb_funcall(mrb, obj1, "==", 1, obj2);
+  result = mrb_funcall_id(mrb, obj1, MRB_QSYM(eq), 1, obj2);
   if (mrb_test(result)) return TRUE;
   return FALSE;
 }
@@ -94,7 +94,7 @@ mrb_true(mrb_state *mrb, mrb_value obj)
 static mrb_value
 nil_to_s(mrb_state *mrb, mrb_value obj)
 {
-  mrb_value str = mrb_str_new_frozen(mrb, 0, 0);
+  mrb_value str = mrb_str_new_frozen(mrb, NULL, 0);
   RSTR_SET_ASCII_FLAG(mrb_str_ptr(str));
   return str;
 }
@@ -315,110 +315,115 @@ mrb_init_object(mrb_state *mrb)
   mrb_define_method(mrb, f, "inspect", false_to_s,  MRB_ARGS_NONE());
 }
 
-static mrb_value
-convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *method, mrb_bool raise)
+static const struct types {
+  const enum mrb_vtype type;
+  const char *name;
+} builtin_types[] = {
+/*    {MRB_TT_NIL,  "nil"}, */
+  {MRB_TT_FALSE,  "false"},
+  {MRB_TT_TRUE,   "true"},
+  {MRB_TT_INTEGER,"Integer"},
+  {MRB_TT_SYMBOL, "Symbol"},  /* :symbol */
+  {MRB_TT_MODULE, "Module"},
+  {MRB_TT_OBJECT, "Object"},
+  {MRB_TT_CLASS,  "Class"},
+  {MRB_TT_ICLASS, "iClass"},  /* internal use: mixed-in module holder */
+  {MRB_TT_SCLASS, "SClass"},
+  {MRB_TT_PROC,   "Proc"},
+#ifndef MRB_NO_FLOAT
+  {MRB_TT_FLOAT,  "Float"},
+#endif
+  {MRB_TT_ARRAY,  "Array"},
+  {MRB_TT_HASH,   "Hash"},
+  {MRB_TT_STRING, "String"},
+  {MRB_TT_RANGE,  "Range"},
+/*    {MRB_TT_BIGNUM,  "Bignum"}, */
+  {MRB_TT_DATA,   "Data"},  /* internal use: wrapped C pointers */
+/*    {MRB_TT_UNDEF,  "undef"}, */ /* internal use: #undef; should not happen */
+  {MRB_TT_MAXDEFINE,  0}
+};
+
+static const char*
+type_name(enum mrb_vtype t)
 {
-  mrb_sym m = 0;
+  const struct types *type = builtin_types;
+
+  while (type->type < MRB_TT_MAXDEFINE) {
+    if (type->type == t) return type->name;
+    type++;
+  }
+  return NULL;
+}
 
-  m = mrb_intern_cstr(mrb, method);
-  if (!mrb_respond_to(mrb, val, m)) {
+static mrb_value
+convert_type(mrb_state *mrb, mrb_value val, const char *tname, mrb_sym method, mrb_bool raise)
+{
+  if (!mrb_respond_to(mrb, val, method)) {
     if (raise) {
-      mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into %s", val, tname);
+      if (tname) mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y into %s", val, tname);
+      mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %Y", val);
     }
     return mrb_nil_value();
   }
-  return mrb_funcall_argv(mrb, val, m, 0, 0);
+  return mrb_funcall_argv(mrb, val, method, 0, 0);
 }
 
 MRB_API mrb_value
-mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method)
+mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method)
 {
   mrb_value v;
+  const char *tname;
 
   if (mrb_type(val) == type) return val;
+  tname = type_name(type);
   v = convert_type(mrb, val, tname, method, TRUE);
   if (mrb_type(v) != type) {
     if (type == MRB_TT_STRING) return mrb_any_to_s(mrb, val);
-    mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%s", val, tname, method);
+    mrb_raisef(mrb, E_TYPE_ERROR, "%v cannot be converted to %s by #%n", val, tname, method);
   }
   return v;
 }
 
 MRB_API mrb_value
-mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method)
+mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method)
 {
   mrb_value v;
 
   if (mrb_type(val) == type && type != MRB_TT_DATA && type != MRB_TT_ISTRUCT) return val;
-  v = convert_type(mrb, val, tname, method, FALSE);
+  v = convert_type(mrb, val, type_name(type), method, FALSE);
   if (mrb_nil_p(v) || mrb_type(v) != type) return mrb_nil_value();
   return v;
 }
 
-static const struct types {
-  unsigned char type;
-  const char *name;
-} builtin_types[] = {
-/*    {MRB_TT_NIL,  "nil"}, */
-  {MRB_TT_FALSE,  "false"},
-  {MRB_TT_TRUE,   "true"},
-  {MRB_TT_FIXNUM, "Fixnum"},
-  {MRB_TT_SYMBOL, "Symbol"},  /* :symbol */
-  {MRB_TT_MODULE, "Module"},
-  {MRB_TT_OBJECT, "Object"},
-  {MRB_TT_CLASS,  "Class"},
-  {MRB_TT_ICLASS, "iClass"},  /* internal use: mixed-in module holder */
-  {MRB_TT_SCLASS, "SClass"},
-  {MRB_TT_PROC,   "Proc"},
-#ifndef MRB_WITHOUT_FLOAT
-  {MRB_TT_FLOAT,  "Float"},
-#endif
-  {MRB_TT_ARRAY,  "Array"},
-  {MRB_TT_HASH,   "Hash"},
-  {MRB_TT_STRING, "String"},
-  {MRB_TT_RANGE,  "Range"},
-/*    {MRB_TT_BIGNUM,  "Bignum"}, */
-  {MRB_TT_DATA,   "Data"},  /* internal use: wrapped C pointers */
-/*    {MRB_TT_VARMAP,  "Varmap"}, */ /* internal use: dynamic variables */
-/*    {MRB_TT_NODE,  "Node"}, */ /* internal use: syntax tree node */
-/*    {MRB_TT_UNDEF,  "undef"}, */ /* internal use: #undef; should not happen */
-  {MRB_TT_MAXDEFINE,  0}
-};
-
 MRB_API void
 mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
 {
-  const struct types *type = builtin_types;
-  enum mrb_vtype xt;
-
-  xt = mrb_type(x);
-  if ((xt != t) || (xt == MRB_TT_DATA) || (xt == MRB_TT_ISTRUCT)) {
-    while (type->type < MRB_TT_MAXDEFINE) {
-      if (type->type == t) {
-        const char *etype;
-
-        if (mrb_nil_p(x)) {
-          etype = "nil";
-        }
-        else if (mrb_fixnum_p(x)) {
-          etype = "Fixnum";
-        }
-        else if (mrb_symbol_p(x)) {
-          etype = "Symbol";
-        }
-        else if (mrb_immediate_p(x)) {
-          etype = RSTRING_PTR(mrb_obj_as_string(mrb, x));
-        }
-        else {
-          etype = mrb_obj_classname(mrb, x);
-        }
-        mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
-                   etype, type->name);
-      }
-      type++;
-    }
-    mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %d (%d given)", t, mrb_type(x));
+  enum mrb_vtype xt = mrb_type(x);
+  const char *tname, *ename;
+
+  if (t == xt) return;
+
+  tname = type_name(t);
+  if (mrb_nil_p(x)) {
+    ename = "nil";
+  }
+  else if (mrb_integer_p(x)) {
+    ename = "Fixnum";
+  }
+  else if (mrb_symbol_p(x)) {
+    ename = "Symbol";
+  }
+  else if (mrb_immediate_p(x)) {
+    ename = RSTRING_PTR(mrb_obj_as_string(mrb, x));
+  }
+  else {
+    ename = mrb_obj_classname(mrb, x);
+  }
+  if (tname) {
+    mrb_raisef(mrb, E_TYPE_ERROR, "wrong argument type %s (expected %s)",
+               ename, tname);
   }
+  mrb_raisef(mrb, E_TYPE_ERROR, "unknown type %d (%s given)", t, ename);
 }
 
 /* 15.3.1.3.46 */
@@ -504,8 +509,8 @@ MRB_API mrb_value
 mrb_to_int(mrb_state *mrb, mrb_value val)
 {
 
-  if (!mrb_fixnum_p(val)) {
-#ifndef MRB_WITHOUT_FLOAT
+  if (!mrb_integer_p(val)) {
+#ifndef MRB_NO_FLOAT
     if (mrb_float_p(val)) {
       return mrb_flo_to_fixnum(mrb, val);
     }
@@ -525,13 +530,13 @@ mrb_convert_to_integer(mrb_state *mrb, mrb_value val, mrb_int base)
     mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Integer");
   }
   switch (mrb_type(val)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
     case MRB_TT_FLOAT:
       if (base != 0) goto arg_error;
       return mrb_flo_to_fixnum(mrb, val);
 #endif
 
-    case MRB_TT_FIXNUM:
+    case MRB_TT_INTEGER:
       if (base != 0) goto arg_error;
       return val;
 
@@ -561,7 +566,7 @@ mrb_Integer(mrb_state *mrb, mrb_value val)
   return mrb_convert_to_integer(mrb, val, 0);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value
 mrb_Float(mrb_state *mrb, mrb_value val)
 {
@@ -569,8 +574,8 @@ mrb_Float(mrb_state *mrb, mrb_value val)
     mrb_raise(mrb, E_TYPE_ERROR, "can't convert nil into Float");
   }
   switch (mrb_type(val)) {
-    case MRB_TT_FIXNUM:
-      return mrb_float_value(mrb, (mrb_float)mrb_fixnum(val));
+    case MRB_TT_INTEGER:
+      return mrb_float_value(mrb, (mrb_float)mrb_integer(val));
 
     case MRB_TT_FLOAT:
       return val;
@@ -579,7 +584,7 @@ mrb_Float(mrb_state *mrb, mrb_value val)
       return mrb_float_value(mrb, mrb_str_to_dbl(mrb, val, TRUE));
 
     default:
-      return mrb_convert_type(mrb, val, MRB_TT_FLOAT, "Float", "to_f");
+      return mrb_type_convert(mrb, val, MRB_TT_FLOAT, MRB_SYM(to_f));
   }
 }
 #endif
@@ -648,12 +653,12 @@ mrb_check_hash_type(mrb_state *mrb, mrb_value hash)
 MRB_API mrb_value
 mrb_inspect(mrb_state *mrb, mrb_value obj)
 {
-  return mrb_obj_as_string(mrb, mrb_funcall(mrb, obj, "inspect", 0));
+  return mrb_obj_as_string(mrb, mrb_funcall_id(mrb, obj, MRB_SYM(inspect), 0));
 }
 
 MRB_API mrb_bool
 mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 {
   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;
-  return mrb_test(mrb_funcall(mrb, obj1, "eql?", 1, obj2));
+  return mrb_test(mrb_funcall_id(mrb, obj1, MRB_QSYM(eql_p), 1, obj2));
 }
diff --git a/src/print.c b/src/print.c
index a75814d81..6bf7da6a5 100644
--- a/src/print.c
+++ b/src/print.c
@@ -60,11 +60,11 @@ mrb_print_error(mrb_state *mrb)
 MRB_API void
 mrb_show_version(mrb_state *mrb)
 {
-  printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_DESCRIPTION")), stdout);
+  printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(MRUBY_DESCRIPTION)), stdout);
 }
 
 MRB_API void
 mrb_show_copyright(mrb_state *mrb)
 {
-  printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_COPYRIGHT")), stdout);
+  printstr(mrb_const_get(mrb, mrb_obj_value(mrb->object_class), MRB_SYM(MRUBY_COPYRIGHT)), stdout);
 }
diff --git a/src/proc.c b/src/proc.c
index c00b09acf..b971b6520 100644
--- a/src/proc.c
+++ b/src/proc.c
@@ -14,8 +14,26 @@ static const mrb_code call_iseq[] = {
   OP_CALL,
 };
 
+static const mrb_irep call_irep = {
+  0,                                   /* nlocals */
+  2,                                   /* nregs */
+  0,                                   /* clen */
+  MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE, /* flags */
+  call_iseq,                           /* iseq */
+  NULL,                                /* pool */
+  NULL,                                /* syms */
+  NULL,                                /* reps */
+  NULL,                                /* lv */
+  NULL,                                /* debug_info */
+  1,                                   /* ilen */
+  0,                                   /* plen */
+  0,                                   /* slen */
+  1,                                   /* rlen */
+  0,                                   /* refcnt */
+};
+
 struct RProc*
-mrb_proc_new(mrb_state *mrb, mrb_irep *irep)
+mrb_proc_new(mrb_state *mrb, const mrb_irep *irep)
 {
   struct RProc *p;
   mrb_callinfo *ci = mrb->c->ci;
@@ -34,7 +52,7 @@ mrb_proc_new(mrb_state *mrb, mrb_irep *irep)
     p->e.target_class = tc;
   }
   p->body.irep = irep;
-  mrb_irep_incref(mrb, irep);
+  mrb_irep_incref(mrb, (mrb_irep*)irep);
 
   return p;
 }
@@ -44,7 +62,7 @@ env_new(mrb_state *mrb, mrb_int nlocals)
 {
   struct REnv *e;
   mrb_callinfo *ci = mrb->c->ci;
-  int bidx;
+  mrb_int bidx;
 
   e = (struct REnv*)mrb_obj_alloc(mrb, MRB_TT_ENV, NULL);
   MRB_ENV_SET_LEN(e, nlocals);
@@ -63,7 +81,7 @@ static void
 closure_setup(mrb_state *mrb, struct RProc *p)
 {
   mrb_callinfo *ci = mrb->c->ci;
-  struct RProc *up = p->upper;
+  const struct RProc *up = p->upper;
   struct REnv *e = NULL;
 
   if (ci && ci->env) {
@@ -90,7 +108,7 @@ closure_setup(mrb_state *mrb, struct RProc *p)
 }
 
 struct RProc*
-mrb_closure_new(mrb_state *mrb, mrb_irep *irep)
+mrb_closure_new(mrb_state *mrb, const mrb_irep *irep)
 {
   struct RProc *p = mrb_proc_new(mrb, irep);
 
@@ -153,7 +171,7 @@ mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals)
 MRB_API mrb_value
 mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx)
 {
-  struct RProc *p = mrb->c->ci->proc;
+  const struct RProc *p = mrb->c->ci->proc;
   struct REnv *e;
 
   if (!p || !MRB_PROC_CFUNC_P(p)) {
@@ -181,7 +199,7 @@ mrb_proc_copy(struct RProc *a, struct RProc *b)
   a->flags = b->flags;
   a->body = b->body;
   if (!MRB_PROC_CFUNC_P(a) && a->body.irep) {
-    a->body.irep->refcnt++;
+    mrb_irep_incref(NULL, (mrb_irep*)a->body.irep);
   }
   a->upper = b->upper;
   a->e.env = b->e.env;
@@ -200,7 +218,7 @@ mrb_proc_s_new(mrb_state *mrb, mrb_value proc_class)
   p = (struct RProc *)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb_class_ptr(proc_class));
   mrb_proc_copy(p, mrb_proc_ptr(blk));
   proc = mrb_obj_value(p);
-  mrb_funcall_with_block(mrb, proc, mrb_intern_lit(mrb, "initialize"), 0, NULL, proc);
+  mrb_funcall_with_block(mrb, proc, MRB_SYM(initialize), 0, NULL, proc);
   if (!MRB_PROC_STRICT_P(p) &&
       mrb->c->ci > mrb->c->cibase && MRB_PROC_ENV(p) == mrb->c->ci[-1].env) {
     p->flags |= MRB_PROC_ORPHAN;
@@ -224,7 +242,7 @@ mrb_proc_init_copy(mrb_state *mrb, mrb_value self)
 static mrb_value
 proc_arity(mrb_state *mrb, mrb_value self)
 {
-  return mrb_fixnum_value(mrb_proc_arity(mrb_proc_ptr(self)));
+  return mrb_int_value(mrb, mrb_proc_arity(mrb_proc_ptr(self)));
 }
 
 /* 15.3.1.2.6  */
@@ -262,7 +280,7 @@ proc_lambda(mrb_state *mrb, mrb_value self)
 mrb_int
 mrb_proc_arity(const struct RProc *p)
 {
-  struct mrb_irep *irep;
+  const mrb_irep *irep;
   const mrb_code *pc;
   mrb_aspec aspec;
   int ma, op, ra, pa, arity;
@@ -293,40 +311,20 @@ mrb_proc_arity(const struct RProc *p)
   return arity;
 }
 
-static void
-tempirep_free(mrb_state *mrb, void *p)
-{
-  if (p) mrb_irep_free(mrb, (mrb_irep *)p);
-}
-
-static const mrb_data_type tempirep_type = { "temporary irep", tempirep_free };
-
 void
 mrb_init_proc(mrb_state *mrb)
 {
   struct RProc *p;
   mrb_method_t m;
-  struct RData *irep_obj = mrb_data_object_alloc(mrb, mrb->object_class, NULL, &tempirep_type);
-  mrb_irep *call_irep;
-  static const mrb_irep mrb_irep_zero = { 0 };
-
-  call_irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep));
-  irep_obj->data = call_irep;
-  *call_irep = mrb_irep_zero;
-  call_irep->flags = MRB_ISEQ_NO_FREE;
-  call_irep->iseq = call_iseq;
-  call_irep->ilen = 1;
-  call_irep->nregs = 2;         /* receiver and block */
 
   mrb_define_class_method(mrb, mrb->proc_class, "new", mrb_proc_s_new, MRB_ARGS_NONE()|MRB_ARGS_BLOCK());
   mrb_define_method(mrb, mrb->proc_class, "initialize_copy", mrb_proc_init_copy, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, mrb->proc_class, "arity", proc_arity, MRB_ARGS_NONE());
 
-  p = mrb_proc_new(mrb, call_irep);
-  irep_obj->data = NULL;
+  p = mrb_proc_new(mrb, &call_irep);
   MRB_METHOD_FROM_PROC(m, p);
-  mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m);
-  mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m);
+  mrb_define_method_raw(mrb, mrb->proc_class, MRB_SYM(call), m);
+  mrb_define_method_raw(mrb, mrb->proc_class, MRB_QSYM(aref), m);
 
   mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.2.6  */
   mrb_define_method(mrb, mrb->kernel_module,       "lambda", proc_lambda, MRB_ARGS_NONE()|MRB_ARGS_BLOCK()); /* 15.3.1.3.27 */
diff --git a/src/range.c b/src/range.c
index 0b4e6dbca..c06a8a00b 100644
--- a/src/range.c
+++ b/src/range.c
@@ -23,11 +23,11 @@ r_check(mrb_state *mrb, mrb_value a, mrb_value b)
 
   ta = mrb_type(a);
   tb = mrb_type(b);
-#ifdef MRB_WITHOUT_FLOAT
-  if (ta == MRB_TT_FIXNUM && tb == MRB_TT_FIXNUM ) {
+#ifdef MRB_NO_FLOAT
+  if (ta == MRB_TT_INTEGER && tb == MRB_TT_INTEGER ) {
 #else
-  if ((ta == MRB_TT_FIXNUM || ta == MRB_TT_FLOAT) &&
-      (tb == MRB_TT_FIXNUM || tb == MRB_TT_FLOAT)) {
+  if ((ta == MRB_TT_INTEGER || ta == MRB_TT_FLOAT) &&
+      (tb == MRB_TT_INTEGER || tb == MRB_TT_FLOAT)) {
 #endif
     return;
   }
@@ -78,7 +78,7 @@ range_ptr_init(mrb_state *mrb, struct RRange *r, mrb_value beg, mrb_value end, m
   if (r) {
     if (RANGE_INITIALIZED_P(r)) {
       /* Ranges are immutable, so that they should be initialized only once. */
-      mrb_name_error(mrb, mrb_intern_lit(mrb, "initialize"), "'initialize' called twice");
+      mrb_name_error(mrb, MRB_SYM(initialize), "'initialize' called twice");
     }
     else {
       range_ptr_alloc_edges(mrb, r);
@@ -328,8 +328,8 @@ mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, con
   result = mrb_ary_new(mrb);
 
   for (i = 0; i < argc; ++i) {
-    if (mrb_fixnum_p(argv[i])) {
-      mrb_ary_push(mrb, result, func(mrb, obj, mrb_fixnum(argv[i])));
+    if (mrb_integer_p(argv[i])) {
+      mrb_ary_push(mrb, result, func(mrb, obj, mrb_integer(argv[i])));
     }
     else if (mrb_range_beg_len(mrb, argv[i], &beg, &len, olen, FALSE) == MRB_RANGE_OK) {
       mrb_int const end = olen < beg + len ? olen : beg + len;
diff --git a/src/state.c b/src/state.c
index 790f7ca13..1f85448a1 100644
--- a/src/state.c
+++ b/src/state.c
@@ -107,12 +107,14 @@ void mrb_free_symtbl(mrb_state *mrb);
 void
 mrb_irep_incref(mrb_state *mrb, mrb_irep *irep)
 {
+  if (irep->flags & MRB_IREP_NO_FREE) return;
   irep->refcnt++;
 }
 
 void
 mrb_irep_decref(mrb_state *mrb, mrb_irep *irep)
 {
+  if (irep->flags & MRB_IREP_NO_FREE) return;
   irep->refcnt--;
   if (irep->refcnt == 0) {
     mrb_irep_free(mrb, irep);
@@ -122,12 +124,14 @@ mrb_irep_decref(mrb_state *mrb, mrb_irep *irep)
 void
 mrb_irep_cutref(mrb_state *mrb, mrb_irep *irep)
 {
-  mrb_irep *tmp;
+  mrb_irep **reps;
   int i;
 
+  if (irep->flags & MRB_IREP_NO_FREE) return;
+  reps = (mrb_irep**)irep->reps;
   for (i=0; i<irep->rlen; i++) {
-    tmp = irep->reps[i];
-    irep->reps[i] = NULL;
+    mrb_irep *tmp = reps[i];
+    reps[i] = NULL;
     if (tmp) mrb_irep_decref(mrb, tmp);
   }
 }
@@ -137,29 +141,26 @@ mrb_irep_free(mrb_state *mrb, mrb_irep *irep)
 {
   int i;
 
+  if (irep->flags & MRB_IREP_NO_FREE) return;
   if (!(irep->flags & MRB_ISEQ_NO_FREE))
     mrb_free(mrb, (void*)irep->iseq);
-  if (irep->pool) for (i=0; i<irep->plen; i++) {
-    if (mrb_string_p(irep->pool[i])) {
-      mrb_gc_free_str(mrb, RSTRING(irep->pool[i]));
-      mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
+  if (irep->pool) {
+    for (i=0; i<irep->plen; i++) {
+      if ((irep->pool[i].tt & 3) == IREP_TT_STR) {
+        mrb_free(mrb, (void*)irep->pool[i].u.str);
+      }
     }
-#if defined(MRB_WORD_BOXING) && !defined(MRB_WITHOUT_FLOAT)
-    else if (mrb_float_p(irep->pool[i])) {
-      mrb_free(mrb, mrb_obj_ptr(irep->pool[i]));
-    }
-#endif
+    mrb_free(mrb, (void*)irep->pool);
   }
-  mrb_free(mrb, irep->pool);
-  mrb_free(mrb, irep->syms);
+  mrb_free(mrb, (void*)irep->syms);
   if (irep->reps) {
     for (i=0; i<irep->rlen; i++) {
       if (irep->reps[i])
-        mrb_irep_decref(mrb, irep->reps[i]);
+        mrb_irep_decref(mrb, (mrb_irep*)irep->reps[i]);
     }
+    mrb_free(mrb, (void*)irep->reps);
   }
-  mrb_free(mrb, irep->reps);
-  mrb_free(mrb, irep->lv);
+  mrb_free(mrb, (void*)irep->lv);
   mrb_debug_info_free(mrb, irep->debug_info);
   mrb_free(mrb, irep);
 }
@@ -170,8 +171,6 @@ mrb_free_context(mrb_state *mrb, struct mrb_context *c)
   if (!c) return;
   mrb_free(mrb, c->stbase);
   mrb_free(mrb, c->cibase);
-  mrb_free(mrb, c->rescue);
-  mrb_free(mrb, c->ensure);
   mrb_free(mrb, c);
 }
 
diff --git a/src/string.c b/src/string.c
index c83e791b6..f27145296 100644
--- a/src/string.c
+++ b/src/string.c
@@ -8,7 +8,7 @@
 # define _CRT_NONSTDC_NO_DEPRECATE
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #include <float.h>
 #include <math.h>
 #endif
@@ -583,9 +583,6 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s)
   else if (RSTR_FSHARED_P(orig)) {
     str_init_fshared(orig, s, orig->as.heap.aux.fshared);
   }
-  else if (mrb_frozen_p(orig) && !RSTR_POOL_P(orig)) {
-    str_init_fshared(orig, s, orig);
-  }
   else {
     if (orig->as.heap.aux.capa > orig->as.heap.len) {
       orig->as.heap.ptr = (char *)mrb_realloc(mrb, orig->as.heap.ptr, len+1);
@@ -597,29 +594,6 @@ str_share(mrb_state *mrb, struct RString *orig, struct RString *s)
 }
 
 mrb_value
-mrb_str_pool(mrb_state *mrb, const char *p, mrb_int len, mrb_bool nofree)
-{
-  struct RString *s = (struct RString *)mrb_malloc(mrb, sizeof(struct RString));
-
-  s->tt = MRB_TT_STRING;
-  s->c = mrb->string_class;
-  s->flags = 0;
-
-  if (RSTR_EMBEDDABLE_P(len)) {
-    str_init_embed(s, p, len);
-  }
-  else if (nofree) {
-    str_init_nofree(s, p, len);
-  }
-  else {
-    str_init_normal(mrb, s, p, len);
-  }
-  RSTR_SET_POOL_FLAG(s);
-  MRB_SET_FROZEN_FLAG(s);
-  return mrb_obj_value(s);
-}
-
-mrb_value
 mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
 {
   struct RString *orig, *s;
@@ -898,7 +872,7 @@ mrb_str_to_cstr(mrb_state *mrb, mrb_value str0)
 MRB_API void
 mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other)
 {
-  other = mrb_str_to_str(mrb, other);
+  other = mrb_obj_as_string(mrb, other);
   mrb_str_cat_str(mrb, self, other);
 }
 
@@ -1111,30 +1085,11 @@ mrb_str_equal_m(mrb_state *mrb, mrb_value str1)
 }
 /* ---------------------------------- */
 
-MRB_API mrb_value
-mrb_str_to_str(mrb_state *mrb, mrb_value str)
-{
-  switch (mrb_type(str)) {
-  case MRB_TT_STRING:
-    return str;
-  case MRB_TT_SYMBOL:
-    return mrb_sym_str(mrb, mrb_symbol(str));
-  case MRB_TT_FIXNUM:
-    return mrb_fixnum_to_str(mrb, str, 10);
-  case MRB_TT_SCLASS:
-  case MRB_TT_CLASS:
-  case MRB_TT_MODULE:
-    return mrb_mod_to_s(mrb, str);
-  default:
-    return mrb_convert_type(mrb, str, MRB_TT_STRING, "String", "to_s");
-  }
-}
-
 /* obslete: use RSTRING_PTR() */
 MRB_API const char*
 mrb_string_value_ptr(mrb_state *mrb, mrb_value str)
 {
-  str = mrb_str_to_str(mrb, str);
+  str = mrb_obj_as_string(mrb, str);
   return RSTRING_PTR(str);
 }
 
@@ -1180,8 +1135,8 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen,
   }
   else {
     switch (mrb_type(indx)) {
-      case MRB_TT_FIXNUM:
-        *beg = mrb_fixnum(indx);
+      case MRB_TT_INTEGER:
+        *beg = mrb_integer(indx);
         *len = 1;
         return STR_CHAR_RANGE;
 
@@ -1196,8 +1151,8 @@ str_convert_range(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen,
 
       default:
         indx = mrb_to_int(mrb, indx);
-        if (mrb_fixnum_p(indx)) {
-          *beg = mrb_fixnum(indx);
+        if (mrb_integer_p(indx)) {
+          *beg = mrb_integer(indx);
           *len = 1;
           return STR_CHAR_RANGE;
         }
@@ -1212,7 +1167,7 @@ range_arg:
             break;
         }
 
-        mrb_raise(mrb, E_TYPE_ERROR, "can't convert to Fixnum");
+        mrb_raise(mrb, E_TYPE_ERROR, "can't convert to Integer");
     }
   }
   return STR_OUT_OF_RANGE;
@@ -1256,8 +1211,8 @@ mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx, mrb_value alen)
  *     str.slice(range)            => new_str or nil
  *     str.slice(other_str)        => new_str or nil
  *
- *  Element Reference---If passed a single <code>Fixnum</code>, returns the code
- *  of the character at that position. If passed two <code>Fixnum</code>
+ *  Element Reference---If passed a single <code>Integer</code>, returns the code
+ *  of the character at that position. If passed two <code>Integer</code>
  *  objects, returns a substring starting at the offset given by the first, and
  *  a length given by the second. If given a range, a substring containing
  *  characters at offsets given by the range is returned. In all three cases, if
@@ -1963,7 +1918,20 @@ mrb_str_intern(mrb_state *mrb, mrb_value self)
 MRB_API mrb_value
 mrb_obj_as_string(mrb_state *mrb, mrb_value obj)
 {
-  return mrb_str_to_str(mrb, obj);
+  switch (mrb_type(obj)) {
+  case MRB_TT_STRING:
+    return obj;
+  case MRB_TT_SYMBOL:
+    return mrb_sym_str(mrb, mrb_symbol(obj));
+  case MRB_TT_INTEGER:
+    return mrb_fixnum_to_str(mrb, obj, 10);
+  case MRB_TT_SCLASS:
+  case MRB_TT_CLASS:
+  case MRB_TT_MODULE:
+    return mrb_mod_to_s(mrb, obj);
+  default:
+    return mrb_type_convert(mrb, obj, MRB_TT_STRING, MRB_SYM(to_s));
+  }
 }
 
 MRB_API mrb_value
@@ -2391,7 +2359,7 @@ mrb_str_len_to_inum(mrb_state *mrb, const char *str, size_t len, mrb_int base, i
     n *= base;
     n += c;
     if (n > (uint64_t)MRB_INT_MAX + (sign ? 0 : 1)) {
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
       if (base == 10) {
         return mrb_float_value(mrb, mrb_str_to_dbl(mrb, mrb_str_new(mrb, str, len), badcheck));
       }
@@ -2502,7 +2470,7 @@ mrb_str_to_i(mrb_state *mrb, mrb_value self)
   return mrb_str_to_inum(mrb, self, base, FALSE);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 double
 mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck)
 {
@@ -2524,8 +2492,8 @@ mrb_str_len_to_dbl(mrb_state *mrb, const char *s, size_t len, mrb_bool badcheck)
 
     if (!badcheck) return 0.0;
     x = mrb_str_len_to_inum(mrb, p, pend-p, 0, badcheck);
-    if (mrb_fixnum_p(x))
-      d = (double)mrb_fixnum(x);
+    if (mrb_integer_p(x))
+      d = (double)mrb_integer(x);
     else /* if (mrb_float_p(x)) */
       d = mrb_float(x);
     return d;
@@ -2900,7 +2868,7 @@ mrb_str_byteslice(mrb_state *mrb, mrb_value str)
       }
     }
     else {
-      beg = mrb_fixnum(mrb_to_int(mrb, a1));
+      beg = mrb_integer(mrb_to_int(mrb, a1));
       len = 1;
       empty = FALSE;
     }
@@ -2963,7 +2931,7 @@ mrb_init_string(mrb_state *mrb)
   mrb_define_method(mrb, s, "slice",           mrb_str_aref_m,          MRB_ARGS_ANY());  /* 15.2.10.5.34 */
   mrb_define_method(mrb, s, "split",           mrb_str_split_m,         MRB_ARGS_ANY());  /* 15.2.10.5.35 */
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_define_method(mrb, s, "to_f",            mrb_str_to_f,            MRB_ARGS_NONE()); /* 15.2.10.5.38 */
 #endif
   mrb_define_method(mrb, s, "to_i",            mrb_str_to_i,            MRB_ARGS_ANY());  /* 15.2.10.5.39 */
@@ -2980,7 +2948,7 @@ mrb_init_string(mrb_state *mrb)
   mrb_define_method(mrb, s, "byteslice",       mrb_str_byteslice,       MRB_ARGS_ARG(1,1));
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 /*
  * Source code for the "strtod" library procedure.
  *
diff --git a/src/symbol.c b/src/symbol.c
index 992848797..add093d14 100644
--- a/src/symbol.c
+++ b/src/symbol.c
@@ -12,6 +12,59 @@
 #include <mruby/dump.h>
 #include <mruby/class.h>
 
+#undef MRB_PRESYM_MAX
+#undef MRB_PRESYM_CSYM
+#undef MRB_PRESYM_QSYM
+#undef MRB_PRESYM_SYM
+#define MRB_PRESYM_CSYM(sym, num) {#sym,sizeof(#sym)-1},
+#define MRB_PRESYM_QSYM(str, name, num) {str,sizeof(str)-1},
+#define MRB_PRESYM_SYM(str, num) {str,sizeof(str)-1},
+
+static const struct {
+  const char *name;
+  uint16_t len;
+} presym_table[] = {
+#include <../build/presym.inc>
+  {0,0}
+};
+
+static mrb_sym
+presym_find(const char *name, size_t len)
+{
+  int start = 0;
+  int end = MRB_PRESYM_MAX-1;
+
+  while (start<=end) {
+    int mid = (start+end)/2;
+    size_t plen = presym_table[mid].len;
+    size_t tlen = (plen > len) ? len : plen;
+    int cmp;
+
+    cmp = memcmp(name, presym_table[mid].name, tlen);
+    if (cmp == 0) {
+      if (len > plen) cmp = 1;
+      else if (len < plen) cmp = -1;
+    }
+
+    if (cmp == 0) {
+      return mid+1;
+    } else if (cmp > 0) {
+      start = mid+1;
+    } else {
+      end = mid-1;
+    }
+  }
+  return 0;
+}
+
+static const char*
+presym_sym2name(mrb_sym sym, mrb_int *lenp)
+{
+  if (sym > MRB_PRESYM_MAX) return NULL;
+  if (lenp) *lenp = presym_table[sym-1].len;
+  return presym_table[sym-1].name;
+}
+
 /* ------------------------------------------------------ */
 typedef struct symbol_name {
   mrb_bool lit : 1;
@@ -20,20 +73,15 @@ typedef struct symbol_name {
   const char *name;
 } symbol_name;
 
-#define SYMBOL_INLINE_BIT_POS       1
-#define SYMBOL_INLINE_LOWER_BIT_POS 2
-#define SYMBOL_INLINE               (1 << (SYMBOL_INLINE_BIT_POS - 1))
-#define SYMBOL_INLINE_LOWER         (1 << (SYMBOL_INLINE_LOWER_BIT_POS - 1))
-#define SYMBOL_NORMAL_SHIFT         SYMBOL_INLINE_BIT_POS
-#define SYMBOL_INLINE_SHIFT         SYMBOL_INLINE_LOWER_BIT_POS
 #ifdef MRB_ENABLE_ALL_SYMBOLS
+#define SYMBOL_SHIFT         0
 # define SYMBOL_INLINE_P(sym) FALSE
-# define SYMBOL_INLINE_LOWER_P(sym) FALSE
 # define sym_inline_pack(name, len) 0
 # define sym_inline_unpack(sym, buf, lenp) NULL
 #else
+#define SYMBOL_INLINE        1
+#define SYMBOL_SHIFT         1
 # define SYMBOL_INLINE_P(sym) ((sym) & SYMBOL_INLINE)
-# define SYMBOL_INLINE_LOWER_P(sym) ((sym) & SYMBOL_INLINE_LOWER)
 #endif
 
 static void
@@ -50,16 +98,14 @@ static const char pack_table[] = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRS
 static mrb_sym
 sym_inline_pack(const char *name, size_t len)
 {
-  const size_t lower_length_max = (MRB_SYMBOL_BIT - 2) / 5;
-  const size_t mix_length_max   = (MRB_SYMBOL_BIT - 2) / 6;
+  const size_t pack_length_max   = (MRB_SYMBOL_BIT - 2) / 6;
 
   char c;
   const char *p;
   size_t i;
   mrb_sym sym = 0;
-  mrb_bool lower = TRUE;
 
-  if (len > lower_length_max) return 0; /* too long */
+  if (len > pack_length_max) return 0; /* too long */
   for (i=0; i<len; i++) {
     uint32_t bits;
 
@@ -68,36 +114,21 @@ sym_inline_pack(const char *name, size_t len)
     p = strchr(pack_table, (int)c);
     if (p == 0) return 0;       /* non alnum char */
     bits = (uint32_t)(p - pack_table)+1;
-    if (bits > 27) lower = FALSE;
-    if (i >= mix_length_max) break;
-    sym |= bits<<(i*6+SYMBOL_INLINE_SHIFT);
+    if (i >= pack_length_max) break;
+    sym |= bits<<(i*6+SYMBOL_SHIFT);
   }
-  if (lower) {
-    sym = 0;
-    for (i=0; i<len; i++) {
-      uint32_t bits;
-
-      c = name[i];
-      p = strchr(pack_table, (int)c);
-      bits = (uint32_t)(p - pack_table)+1;
-      sym |= bits<<(i*5+SYMBOL_INLINE_SHIFT);
-    }
-    return sym | SYMBOL_INLINE | SYMBOL_INLINE_LOWER;
-  }
-  if (len > mix_length_max) return 0;
   return sym | SYMBOL_INLINE;
 }
 
 static const char*
 sym_inline_unpack(mrb_sym sym, char *buf, mrb_int *lenp)
 {
-  int bit_per_char = SYMBOL_INLINE_LOWER_P(sym) ? 5 : 6;
   int i;
 
   mrb_assert(SYMBOL_INLINE_P(sym));
 
-  for (i=0; i<30/bit_per_char; i++) {
-    uint32_t bits = sym>>(i*bit_per_char+SYMBOL_INLINE_SHIFT) & ((1<<bit_per_char)-1);
+  for (i=0; i<5; i++) {
+    uint32_t bits = sym>>(i*6+SYMBOL_SHIFT) & ((1<<6)-1);
     if (bits == 0) break;
     buf[i] = pack_table[bits-1];;
   }
@@ -130,6 +161,10 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp)
   symbol_name *sname;
   uint8_t hash;
 
+  /* presym */
+  i = presym_find(name, len);
+  if (i > 0) return i<<SYMBOL_SHIFT;
+
   /* inline symbol */
   i = sym_inline_pack(name, len);
   if (i > 0) return i;
@@ -142,14 +177,14 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp)
   do {
     sname = &mrb->symtbl[i];
     if (sname->len == len && memcmp(sname->name, name, len) == 0) {
-      return i<<SYMBOL_NORMAL_SHIFT;
+      return (i+MRB_PRESYM_MAX)<<SYMBOL_SHIFT;
     }
     if (sname->prev == 0xff) {
       i -= 0xff;
       sname = &mrb->symtbl[i];
       while (mrb->symtbl < sname) {
         if (sname->len == len && memcmp(sname->name, name, len) == 0) {
-          return (mrb_sym)(sname - mrb->symtbl)<<SYMBOL_NORMAL_SHIFT;
+          return (mrb_sym)(sname - mrb->symtbl)<<SYMBOL_SHIFT;
         }
         sname--;
       }
@@ -205,7 +240,7 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)
   }
   mrb->symhash[hash] = mrb->symidx = sym;
 
-  return sym<<SYMBOL_NORMAL_SHIFT;
+  return (sym+MRB_PRESYM_MAX)<<SYMBOL_SHIFT;
 }
 
 MRB_API mrb_sym
@@ -232,27 +267,51 @@ mrb_intern_str(mrb_state *mrb, mrb_value str)
   return mrb_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
 }
 
-MRB_API mrb_value
-mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
+MRB_API mrb_sym
+mrb_intern_check(mrb_state *mrb, const char *name, size_t len)
 {
   mrb_sym sym;
 
   sym_validate_len(mrb, len);
   sym = find_symbol(mrb, name, len, NULL);
-  if (sym > 0) return mrb_symbol_value(sym);
-  return mrb_nil_value();
+  if (sym > 0) return sym;
+  return 0;
+}
+
+MRB_API mrb_value
+mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
+{
+  mrb_sym sym = mrb_intern_check(mrb, name, len);
+  if (sym == 0) return mrb_nil_value();
+  return mrb_symbol_value(sym);
+}
+
+MRB_API mrb_sym
+mrb_intern_check_cstr(mrb_state *mrb, const char *name)
+{
+  return mrb_intern_check(mrb, name, strlen(name));
 }
 
 MRB_API mrb_value
 mrb_check_intern_cstr(mrb_state *mrb, const char *name)
 {
-  return mrb_check_intern(mrb, name, strlen(name));
+  mrb_sym sym = mrb_intern_check_cstr(mrb, name);
+  if (sym == 0) return mrb_nil_value();
+  return mrb_symbol_value(sym);
+}
+
+MRB_API mrb_sym
+mrb_intern_check_str(mrb_state *mrb, mrb_value str)
+{
+  return mrb_intern_check(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
 }
 
 MRB_API mrb_value
 mrb_check_intern_str(mrb_state *mrb, mrb_value str)
 {
-  return mrb_check_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
+  mrb_sym sym = mrb_intern_check_str(mrb, str);
+  if (sym == 0) return mrb_nil_value();
+  return mrb_symbol_value(sym);
 }
 
 static const char*
@@ -260,7 +319,13 @@ sym2name_len(mrb_state *mrb, mrb_sym sym, char *buf, mrb_int *lenp)
 {
   if (SYMBOL_INLINE_P(sym)) return sym_inline_unpack(sym, buf, lenp);
 
-  sym >>= SYMBOL_NORMAL_SHIFT;
+  sym >>= SYMBOL_SHIFT;
+  {
+    const char *name = presym_sym2name(sym, lenp);
+    if (name) return name;
+  }
+  sym -= MRB_PRESYM_MAX;
+  
   if (sym == 0 || mrb->symidx < sym) {
     if (lenp) *lenp = 0;
     return NULL;
@@ -276,6 +341,15 @@ mrb_sym_name_len(mrb_state *mrb, mrb_sym sym, mrb_int *lenp)
   return sym2name_len(mrb, sym, mrb->symbuf, lenp);
 }
 
+mrb_bool
+mrb_sym_static_p(mrb_state *mrb, mrb_sym sym)
+{
+  if (SYMBOL_INLINE_P(sym)) return TRUE;
+  sym >>= SYMBOL_SHIFT;
+  if (sym > MRB_PRESYM_MAX) return FALSE;
+  return TRUE;
+}
+
 void
 mrb_free_symtbl(mrb_state *mrb)
 {
@@ -497,7 +571,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
   char *sp;
 
   name = mrb_sym_name_len(mrb, id, &len);
-  str = mrb_str_new(mrb, 0, len+1);
+  str = mrb_str_new(mrb, NULL, len+1);
   sp = RSTRING_PTR(str);
   sp[0] = ':';
   memcpy(sp+1, name, len);
diff --git a/src/value_array.h b/src/value_array.h
index bc5f28b06..6089b8aa0 100644
--- a/src/value_array.h
+++ b/src/value_array.h
@@ -6,6 +6,7 @@
 static inline void
 value_move(mrb_value *s1, const mrb_value *s2, size_t n)
 {
+  if (n == 0) return;
   if (s1 > s2 && s1 < s2 + n)
   {
     s1 += n;
diff --git a/src/variable.c b/src/variable.c
index c36fea6e3..f1375fd4d 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -11,21 +11,16 @@
 #include <mruby/string.h>
 #include <mruby/variable.h>
 
-#ifndef MRB_IV_SEGMENT_SIZE
-#define MRB_IV_SEGMENT_SIZE 4
-#endif
-
-typedef struct segment {
-  mrb_sym key[MRB_IV_SEGMENT_SIZE];
-  mrb_value val[MRB_IV_SEGMENT_SIZE];
-  struct segment *next;
-} segment;
+struct iv_elem {
+  mrb_sym key;
+  mrb_value val;
+};
 
 /* Instance variable table structure */
 typedef struct iv_tbl {
-  segment *rootseg;
   size_t size;
-  size_t last_len;
+  size_t alloc;
+  struct iv_elem *table;
 } iv_tbl;
 
 /* Creates the instance variable table. */
@@ -36,67 +31,82 @@ iv_new(mrb_state *mrb)
 
   t = (iv_tbl*)mrb_malloc(mrb, sizeof(iv_tbl));
   t->size = 0;
-  t->rootseg =  NULL;
-  t->last_len = 0;
+  t->alloc = 0;
+  t->table = NULL;
 
   return t;
 }
 
+static void iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val);
+
+static void
+iv_rehash(mrb_state *mrb, iv_tbl *t)
+{
+  size_t old_alloc = t->alloc;
+  size_t new_alloc = old_alloc+1;
+  struct iv_elem *old_table = t->table;
+
+  khash_power2(new_alloc);
+  if (old_alloc == new_alloc) return;
+
+  t->alloc = new_alloc;
+  t->size = 0;
+  t->table = (struct iv_elem*)mrb_calloc(mrb, sizeof(struct iv_elem), new_alloc);
+
+  for (size_t i = 0; i < old_alloc; i++) {
+    struct iv_elem *slot = &old_table[i];
+
+    /* key = 0 means empty; val = undef means deleted */
+    if (slot->key != 0 && !mrb_undef_p(slot->val)) {
+      iv_put(mrb, t, slot->key, slot->val);
+    }
+  }
+  mrb_free(mrb, old_table);
+}
+
+#define slot_empty_p(slot) ((slot)->key == 0 && !mrb_undef_p((slot)->val))
+
 /* Set the value for the symbol in the instance variable table. */
 static void
 iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
 {
-  segment *seg;
-  segment *prev = NULL;
-  segment *matched_seg = NULL;
-  size_t matched_idx = 0;
-  size_t i;
+  size_t hash, pos, start;
+  struct iv_elem *dslot = NULL;
 
   if (t == NULL) return;
-  seg = t->rootseg;
-  while (seg) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
-      /* Found room in last segment after last_len */
-      if (!seg->next && i >= t->last_len) {
-        seg->key[i] = sym;
-        seg->val[i] = val;
-        t->last_len = i+1;
+  if (t->alloc == 0) {
+    iv_rehash(mrb, t);
+  }
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct iv_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      slot->val = val;
+      return;
+    }
+    else if (slot_empty_p(slot)) {
+      t->size++;
+      slot->key = sym;
+      slot->val = val;
+      return;
+    }
+    else if (!dslot && mrb_undef_p(slot->val)) { /* deleted */
+      dslot = slot;
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      if (dslot) {
         t->size++;
+        dslot->key = sym;
+        dslot->val = val;
         return;
       }
-      if (!matched_seg && key == 0) {
-        matched_seg = seg;
-        matched_idx = i;
-      }
-      else if (key == sym) {
-        seg->val[i] = val;
-        return;
-      }
+      /* no room */
+      iv_rehash(mrb, t);
+      start = pos = hash & (t->alloc-1);
     }
-    prev = seg;
-    seg = seg->next;
-  }
-
-  /* Not found */
-  if (matched_seg) {
-    matched_seg->key[matched_idx] = sym;
-    matched_seg->val[matched_idx] = val;
-    t->size++;
-    return;
-  }
-
-  seg = (segment*)mrb_malloc(mrb, sizeof(segment));
-  seg->next = NULL;
-  seg->key[0] = sym;
-  seg->val[0] = val;
-  t->last_len = 1;
-  t->size++;
-  if (prev) {
-    prev->next = seg;
-  }
-  else {
-    t->rootseg = seg;
   }
 }
 
@@ -104,80 +114,81 @@ iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
 static mrb_bool
 iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 {
-  segment *seg;
-  size_t i;
+  size_t hash, pos, start;
 
   if (t == NULL) return FALSE;
-  seg = t->rootseg;
-  while (seg) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
+  if (t->alloc == 0) return FALSE;
+  if (t->size == 0) return FALSE;
 
-      if (!seg->next && i >= t->last_len) {
-        return FALSE;
-      }
-      if (key == sym) {
-        if (vp) *vp = seg->val[i];
-        return TRUE;
-      }
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct iv_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      if (vp) *vp = slot->val;
+      return TRUE;
+    }
+    else if (slot_empty_p(slot)) {
+      return FALSE;
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      return FALSE;
     }
-    seg = seg->next;
   }
-  return FALSE;
 }
 
 /* Deletes the value for the symbol from the instance variable table. */
 static mrb_bool
 iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 {
-  segment *seg;
-  size_t i;
+  size_t hash, pos, start;
 
   if (t == NULL) return FALSE;
-  seg = t->rootseg;
-  while (seg) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
+  if (t->alloc == 0) return  FALSE;
+  if (t->size == 0) return FALSE;
 
-      if (!seg->next && i >= t->last_len) {
-        return FALSE;
-      }
-      if (key == sym) {
-        t->size--;
-        seg->key[i] = 0;
-        if (vp) *vp = seg->val[i];
-        return TRUE;
-      }
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct iv_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      if (vp) *vp = slot->val;
+      t->size--;
+      slot->key = 0;
+      slot->val = mrb_undef_value();
+      return TRUE;
+    }
+    else if (slot_empty_p(slot)) {
+      return FALSE;
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      return FALSE;
     }
-    seg = seg->next;
   }
-  return FALSE;
 }
 
 /* Iterates over the instance variable table. */
 static void
 iv_foreach(mrb_state *mrb, iv_tbl *t, mrb_iv_foreach_func *func, void *p)
 {
-  segment *seg;
   size_t i;
 
   if (t == NULL) return;
-  seg = t->rootseg;
-  while (seg) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
+  if (t->alloc == 0) return;
+  if (t->size == 0) return;
 
-      /* no value in last segment after last_len */
-      if (!seg->next && i >= t->last_len) {
+  for (i=0; i<t->alloc; i++) {
+    struct iv_elem *slot = &t->table[i];
+
+    if (slot->key && !mrb_undef_p(slot->val)) {
+      if ((*func)(mrb, slot->key, slot->val, p) != 0) {
         return;
       }
-      if (key != 0) {
-        if ((*func)(mrb, key, seg->val[i], p) != 0) {
-          return;
-        }
-      }
     }
-    seg = seg->next;
   }
   return;
 }
@@ -186,47 +197,28 @@ iv_foreach(mrb_state *mrb, iv_tbl *t, mrb_iv_foreach_func *func, void *p)
 static size_t
 iv_size(mrb_state *mrb, iv_tbl *t)
 {
-  segment *seg;
-  size_t size = 0;
-
   if (t == NULL) return 0;
-  if (t->size > 0) return t->size;
-  seg = t->rootseg;
-  while (seg) {
-    if (seg->next == NULL) {
-      size += t->last_len;
-      return size;
-    }
-    seg = seg->next;
-    size += MRB_IV_SEGMENT_SIZE;
-  }
-  /* empty iv_tbl */
-  return 0;
+  return t->size;
 }
 
 /* Copy the instance variable table. */
 static iv_tbl*
 iv_copy(mrb_state *mrb, iv_tbl *t)
 {
-  segment *seg;
   iv_tbl *t2;
-
   size_t i;
 
-  seg = t->rootseg;
-  t2 = iv_new(mrb);
+  if (t == NULL) return NULL;
+  if (t->alloc == 0) return NULL;
+  if (t->size == 0) return NULL;
 
-  while (seg != NULL) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
-      mrb_value val = seg->val[i];
+  t2 = iv_new(mrb);
+  for (i=0; i<t->alloc; i++) {
+    struct iv_elem *slot = &t->table[i];
 
-      if ((seg->next == NULL) && (i >= t->last_len)) {
-        return t2;
-      }
-      iv_put(mrb, t2, key, val);
+    if (slot->key && !mrb_undef_p(slot->val)) {
+      iv_put(mrb, t2, slot->key, slot->val);
     }
-    seg = seg->next;
   }
   return t2;
 }
@@ -235,14 +227,7 @@ iv_copy(mrb_state *mrb, iv_tbl *t)
 static void
 iv_free(mrb_state *mrb, iv_tbl *t)
 {
-  segment *seg;
-
-  seg = t->rootseg;
-  while (seg) {
-    segment *p = seg;
-    seg = seg->next;
-    mrb_free(mrb, p);
-  }
+  mrb_free(mrb, t->table);
   mrb_free(mrb, t);
 }
 
@@ -379,11 +364,11 @@ assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   if (namespace_p(obj->tt) && namespace_p(mrb_type(v))) {
     struct RObject *c = mrb_obj_ptr(v);
     if (obj != c && ISUPPER(mrb_sym_name_len(mrb, sym, NULL)[0])) {
-      mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__");
+      mrb_sym id_classname = MRB_SYM(__classname__);
       mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
 
       if (mrb_nil_p(o)) {
-        mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__");
+        mrb_sym id_outer = MRB_SYM(__outer__);
         o = mrb_obj_iv_get(mrb, c, id_outer);
 
         if (mrb_nil_p(o)) {
@@ -643,8 +628,7 @@ mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
   if (cls && cls->tt == MRB_TT_SCLASS) {
     mrb_value klass;
 
-    klass = mrb_obj_iv_get(mrb, (struct RObject *)cls,
-                           mrb_intern_lit(mrb, "__attached__"));
+    klass = mrb_obj_iv_get(mrb, (struct RObject *)cls, MRB_SYM(__attached__));
     c = mrb_class_ptr(klass);
     if (c->tt == MRB_TT_CLASS || c->tt == MRB_TT_MODULE) {
       given = FALSE;
@@ -688,8 +672,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
   if (cls && cls->tt == MRB_TT_SCLASS) {
     mrb_value klass;
 
-    klass = mrb_obj_iv_get(mrb, (struct RObject*)cls,
-                           mrb_intern_lit(mrb, "__attached__"));
+    klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__));
     switch (mrb_type(klass)) {
     case MRB_TT_CLASS:
     case MRB_TT_MODULE:
@@ -743,11 +726,11 @@ mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
 {
   struct RClass *c;
 
-  struct RProc *p = mrb->c->ci->proc;
+  const struct RProc *p = mrb->c->ci->proc;
 
   for (;;) {
     c = MRB_PROC_TARGET_CLASS(p);
-    if (c->tt != MRB_TT_SCLASS) break;
+    if (c && c->tt != MRB_TT_SCLASS) break;
     p = p->upper;
   }
   return mrb_mod_cv_get(mrb, c, sym);
@@ -757,11 +740,11 @@ void
 mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
   struct RClass *c;
-  struct RProc *p = mrb->c->ci->proc;
+  const struct RProc *p = mrb->c->ci->proc;
 
   for (;;) {
     c = MRB_PROC_TARGET_CLASS(p);
-    if (c->tt != MRB_TT_SCLASS) break;
+    if (c && c->tt != MRB_TT_SCLASS) break;
     p = p->upper;
   }
   mrb_mod_cv_set(mrb, c, sym, v);
@@ -803,7 +786,7 @@ L_RETRY:
     goto L_RETRY;
   }
   name = mrb_symbol_value(sym);
-  return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name);
+  return mrb_funcall_argv(mrb, mrb_obj_value(base), MRB_SYM(const_missing), 1, &name);
 }
 
 MRB_API mrb_value
@@ -819,9 +802,10 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
   struct RClass *c;
   struct RClass *c2;
   mrb_value v;
-  struct RProc *proc;
+  const struct RProc *proc;
 
   c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+  if (!c) c = mrb->object_class;
   if (iv_get(mrb, c->iv, sym, &v)) {
     return v;
   }
@@ -829,7 +813,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
   while (c2 && c2->tt == MRB_TT_SCLASS) {
     mrb_value klass;
 
-    if (!iv_get(mrb, c2->iv, mrb_intern_lit(mrb, "__attached__"), &klass)) {
+    if (!iv_get(mrb, c2->iv, MRB_SYM(__attached__), &klass)) {
       c2 = NULL;
       break;
     }
@@ -864,6 +848,7 @@ mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   struct RClass *c;
 
   c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+  if (!c) c = mrb->object_class;
   mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v);
 }
 
@@ -875,6 +860,12 @@ mrb_const_remove(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 }
 
 MRB_API void
+mrb_define_const_id(mrb_state *mrb, struct RClass *mod, mrb_sym name, mrb_value v)
+{
+  mrb_obj_iv_set(mrb, (struct RObject*)mod, name, v);
+}
+
+MRB_API void
 mrb_define_const(mrb_state *mrb, struct RClass *mod, const char *name, mrb_value v)
 {
   mrb_obj_iv_set(mrb, (struct RObject*)mod, mrb_intern_cstr(mrb, name), v);
@@ -1070,7 +1061,7 @@ outer_class(mrb_state *mrb, struct RClass *c)
 {
   mrb_value ov;
 
-  ov = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"));
+  ov = mrb_obj_iv_get(mrb, (struct RObject*)c, MRB_SYM(__outer__));
   if (mrb_nil_p(ov)) return NULL;
   switch (mrb_type(ov)) {
   case MRB_TT_CLASS:
@@ -1120,8 +1111,8 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
   str = mrb_sym_name_len(mrb, name, &len);
   mrb_str_cat(mrb, path, str, len);
   if (RSTRING_PTR(path)[0] != '#') {
-    iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
-    iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
+    iv_del(mrb, c->iv, MRB_SYM(__outer__), NULL);
+    iv_put(mrb, c->iv, MRB_SYM(__classname__), path);
     mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
     path = mrb_str_dup(mrb, path);
   }
@@ -1131,16 +1122,9 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
 size_t
 mrb_obj_iv_tbl_memsize(mrb_state* mrb, mrb_value obj)
 {
-  size_t nseg = 0;
-  segment *seg;
-
-  if (mrb_obj_ptr(obj)->iv == NULL) return 0;
-  seg = mrb_obj_ptr(obj)->iv->rootseg;
-  while (seg) {
-    nseg++;
-    seg = seg->next;
-  }
-  return sizeof(iv_tbl) + sizeof(segment)*nseg;
+  iv_tbl *t = mrb_obj_ptr(obj)->iv;
+  if (t == NULL) return 0;
+  return sizeof(iv_tbl) + t->alloc*sizeof(struct iv_elem);
 }
 
 #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
diff --git a/src/vm.c b/src/vm.c
index cc9a187b7..d1f4660be 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -6,7 +6,7 @@
 
 #include <stddef.h>
 #include <stdarg.h>
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #include <math.h>
 #endif
 #include <mruby.h>
@@ -23,6 +23,7 @@
 #include <mruby/opcode.h>
 #include "value_array.h"
 #include <mruby/throw.h>
+#include <mruby/dump.h>
 
 #ifdef MRB_DISABLE_STDIO
 #if defined(__cplusplus)
@@ -222,9 +223,9 @@ mrb_stack_extend(mrb_state *mrb, mrb_int room)
 }
 
 static inline struct REnv*
-uvenv(mrb_state *mrb, int up)
+uvenv(mrb_state *mrb, mrb_int up)
 {
-  struct RProc *proc = mrb->c->ci->proc;
+  const struct RProc *proc = mrb->c->ci->proc;
   struct REnv *e;
 
   while (up--) {
@@ -247,8 +248,8 @@ uvenv(mrb_state *mrb, int up)
   return NULL;
 }
 
-static inline struct RProc*
-top_proc(mrb_state *mrb, struct RProc *proc)
+static inline const struct RProc*
+top_proc(mrb_state *mrb, const struct RProc *proc)
 {
   while (proc->upper) {
     if (MRB_PROC_SCOPE_P(proc) || MRB_PROC_STRICT_P(proc))
@@ -263,8 +264,8 @@ top_proc(mrb_state *mrb, struct RProc *proc)
 #define CI_ACC_RESUMED -3
 
 static inline mrb_callinfo*
-cipush(mrb_state *mrb, const mrb_code *pc, int push_stacks, int acc,
-    struct RClass *target_class, struct RProc *proc, mrb_sym mid, int argc)
+cipush(mrb_state *mrb, const mrb_code *pc, mrb_int push_stacks, mrb_int acc,
+       struct RClass *target_class, const struct RProc *proc, mrb_sym mid, mrb_int argc)
 {
   struct mrb_context *c = mrb->c;
   mrb_callinfo *ci = c->ci;
@@ -280,8 +281,6 @@ cipush(mrb_state *mrb, const mrb_code *pc, int push_stacks, int acc,
   ci->mid = mid;
   ci->proc = proc;
   ci->stackent = c->stack;
-  ci->epos = c->eidx;
-  ci->ridx = ci[-1].ridx;
   ci->pc = pc;
   ci->argc = argc;
   ci->acc = acc;
@@ -327,55 +326,7 @@ cipop(mrb_state *mrb)
 }
 
 void mrb_exc_set(mrb_state *mrb, mrb_value exc);
-static mrb_value mrb_run(mrb_state *mrb, struct RProc* proc, mrb_value self);
-
-static void
-ecall(mrb_state *mrb)
-{
-  struct RProc *p;
-  struct mrb_context *c = mrb->c;
-  mrb_callinfo *ci = c->ci;
-  struct RObject *exc;
-  struct REnv *env;
-  ptrdiff_t cioff;
-  int ai = mrb_gc_arena_save(mrb);
-  uint16_t i;
-  int nregs;
-
-  if (c->eidx == 0) return;
-  i = --c->eidx;
-
-  /* restrict total call depth of ecall() */
-  if (++mrb->ecall_nest > MRB_ECALL_DEPTH_MAX) {
-    mrb_exc_raise(mrb, mrb_obj_value(mrb->stack_err));
-  }
-  p = c->ensure[i];
-  if (!p) return;
-  mrb_assert(!MRB_PROC_CFUNC_P(p));
-  c->ensure[i] = NULL;
-  nregs = p->upper->body.irep->nregs;
-  if (ci->proc && !MRB_PROC_CFUNC_P(ci->proc) &&
-      ci->proc->body.irep->nregs > nregs) {
-    nregs = ci->proc->body.irep->nregs;
-  }
-  cioff = ci - c->cibase;
-  ci = cipush(mrb, NULL, nregs, CI_ACC_SKIP, MRB_PROC_TARGET_CLASS(p), p, ci->mid, 0);
-  env = MRB_PROC_ENV(p);
-  mrb_assert(env);
-  exc = mrb->exc; mrb->exc = 0;
-  if (exc) {
-    mrb_gc_protect(mrb, mrb_obj_value(exc));
-  }
-  if (mrb->c->fib) {
-    mrb_gc_protect(mrb, mrb_obj_value(mrb->c->fib));
-  }
-  mrb_run(mrb, p, env->stack[0]);
-  mrb->c = c;
-  c->ci = c->cibase + cioff;
-  if (!mrb->exc) mrb->exc = exc;
-  mrb_gc_arena_restore(mrb, ai);
-  mrb->ecall_nest--;
-}
+static mrb_value mrb_run(mrb_state *mrb, const struct RProc* proc, mrb_value self);
 
 #ifndef MRB_FUNCALL_ARGC_MAX
 #define MRB_FUNCALL_ARGC_MAX 16
@@ -401,11 +352,30 @@ mrb_funcall(mrb_state *mrb, mrb_value self, const char *name, mrb_int argc, ...)
   return mrb_funcall_argv(mrb, self, mid, argc, argv);
 }
 
-static int
+MRB_API mrb_value
+mrb_funcall_id(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc, ...)
+{
+  mrb_value argv[MRB_FUNCALL_ARGC_MAX];
+  va_list ap;
+  mrb_int i;
+
+  if (argc > MRB_FUNCALL_ARGC_MAX) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "Too long arguments. (limit=" MRB_STRINGIZE(MRB_FUNCALL_ARGC_MAX) ")");
+  }
+
+  va_start(ap, argc);
+  for (i = 0; i < argc; i++) {
+    argv[i] = va_arg(ap, mrb_value);
+  }
+  va_end(ap);
+  return mrb_funcall_argv(mrb, self, mid, argc, argv);
+}
+
+static mrb_int
 ci_nregs(mrb_callinfo *ci)
 {
-  struct RProc *p;
-  int n = 0;
+  const struct RProc *p;
+  mrb_int n = 0;
 
   if (!ci) return 3;
   p = ci->proc;
@@ -455,7 +425,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
     mrb_method_t m;
     struct RClass *c;
     mrb_callinfo *ci;
-    int n = ci_nregs(mrb->c->ci);
+    mrb_int n = ci_nregs(mrb->c->ci);
     ptrdiff_t voff = -1;
 
     if (!mrb->c->stack) {
@@ -467,7 +437,7 @@ mrb_funcall_with_block(mrb_state *mrb, mrb_value self, mrb_sym mid, mrb_int argc
     c = mrb_class(mrb, self);
     m = mrb_method_search_vm(mrb, &c, mid);
     if (MRB_METHOD_UNDEF_P(m)) {
-      mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
+      mrb_sym missing = MRB_SYM(method_missing);
       mrb_value args = mrb_ary_new_from_values(mrb, argc, argv);
       m = mrb_method_search_vm(mrb, &c, missing);
       if (MRB_METHOD_UNDEF_P(m)) {
@@ -536,7 +506,7 @@ mrb_value
 mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p)
 {
   mrb_callinfo *ci = mrb->c->ci;
-  int keep, nregs;
+  mrb_int keep, nregs;
 
   mrb->c->stack[0] = self;
   ci->proc = p;
@@ -721,7 +691,7 @@ mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value
   mrb_sym mid = mrb->c->ci->mid;
   mrb_callinfo *ci;
   mrb_value val;
-  int n;
+  mrb_int n;
 
   if (mrb_nil_p(b)) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "no block given");
@@ -802,17 +772,56 @@ mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const
 }
 
 static struct RBreak*
-break_new(mrb_state *mrb, struct RProc *p, mrb_value val)
+break_new(mrb_state *mrb, uint32_t tag, const struct RProc *p, mrb_value val)
 {
   struct RBreak *brk;
 
   brk = (struct RBreak*)mrb_obj_alloc(mrb, MRB_TT_BREAK, NULL);
   mrb_break_proc_set(brk, p);
   mrb_break_value_set(brk, val);
+  mrb_break_tag_set(brk, tag);
 
   return brk;
 }
 
+#define MRB_CATCH_FILTER_RESCUE (UINT32_C(1) << MRB_CATCH_RESCUE)
+#define MRB_CATCH_FILTER_ENSURE (UINT32_C(1) << MRB_CATCH_ENSURE)
+#define MRB_CATCH_FILTER_ALL    (MRB_CATCH_FILTER_RESCUE | MRB_CATCH_FILTER_ENSURE)
+
+static const struct mrb_irep_catch_handler *
+catch_handler_find(mrb_state *mrb, mrb_callinfo *ci, const mrb_code *pc, uint32_t filter)
+{
+  const mrb_irep *irep;
+  ptrdiff_t xpc;
+  size_t cnt;
+  const struct mrb_irep_catch_handler *e;
+
+/* The comparison operators use `>` and `<=` because pc already points to the next instruction */
+#define catch_cover_p(pc, beg, end) ((pc) > (beg) && (pc) <= (end))
+
+  if (ci->proc == NULL || MRB_PROC_CFUNC_P(ci->proc)) return NULL;
+  irep = ci->proc->body.irep;
+  if (irep->clen < 1) return NULL;
+  xpc = pc - irep->iseq;
+  /* If it retry at the top level, pc will be 0, so check with -1 as the start position */
+  mrb_assert(catch_cover_p(xpc, -1, irep->ilen));
+  if (!catch_cover_p(xpc, -1, irep->ilen)) return NULL;
+
+  /* Currently uses a simple linear search to avoid processing complexity. */
+  cnt = irep->clen;
+  e = mrb_irep_catch_handler_table(irep) + cnt - 1;
+  for (; cnt > 0; cnt --, e --) {
+    if (((UINT32_C(1) << e->type) & filter) &&
+        catch_cover_p(xpc, bin_to_uint16(e->begin), bin_to_uint16(e->end))) {
+      return e;
+    }
+  }
+
+#undef catch_cover_p
+
+  return NULL;
+}
+
 typedef enum {
   LOCALJUMP_ERROR_RETURN = 0,
   LOCALJUMP_ERROR_BREAK = 1,
@@ -859,6 +868,70 @@ argnum_error(mrb_state *mrb, mrb_int num)
   mrb_exc_set(mrb, exc);
 }
 
+static mrb_bool
+break_tag_p(struct RBreak *brk, uint32_t tag)
+{
+  return (brk != NULL && brk->tt == MRB_TT_BREAK) ? TRUE : FALSE;
+}
+
+static void
+prepare_tagged_break(mrb_state *mrb, uint32_t tag, const struct RProc *proc, mrb_value val)
+{
+  if (break_tag_p((struct RBreak*)mrb->exc, tag)) {
+    mrb_break_tag_set((struct RBreak*)mrb->exc, tag);
+  }
+  else {
+    mrb->exc = (struct RObject*)break_new(mrb, tag, proc, val);
+  }
+}
+
+#define THROW_TAGGED_BREAK(mrb, tag, proc, val) \
+  do { \
+    prepare_tagged_break(mrb, tag, proc, val); \
+    goto L_CATCH_TAGGED_BREAK; \
+  } while (0)
+
+#define UNWIND_ENSURE(mrb, ci, pc, tag, proc, val) \
+  do { \
+    ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ENSURE); \
+    if (ch) { \
+      THROW_TAGGED_BREAK(mrb, tag, proc, val); \
+    } \
+  } while (0)
+
+/*
+ *  CHECKPOINT_RESTORE(tag) {
+ *    This part is executed when jumping by the same "tag" of RBreak (it is not executed the first time).
+ *    Write the code required (initialization of variables, etc.) for the subsequent processing.
+ *  }
+ *  CHECKPOINT_MAIN(tag) {
+ *    This part is always executed.
+ *  }
+ *  CHECKPOINT_END(tag);
+ *
+ *  ...
+ *
+ *  // Jump to CHECKPOINT_RESTORE with the same "tag".
+ *  goto CHECKPOINT_LABEL_MAKE(tag);
+ */
+
+#define CHECKPOINT_LABEL_MAKE(tag) L_CHECKPOINT_ ## tag
+
+#define CHECKPOINT_RESTORE(tag) \
+  do { \
+    if (FALSE) { \
+      CHECKPOINT_LABEL_MAKE(tag): \
+      do {
+
+#define CHECKPOINT_MAIN(tag) \
+      } while (0); \
+    } \
+    do {
+
+#define CHECKPOINT_END(tag) \
+    } while (0); \
+  } while (0)
+
 #define ERR_PC_SET(mrb) mrb->c->ci->err = pc0;
 #define ERR_PC_CLR(mrb) mrb->c->ci->err = 0;
 #ifdef MRB_ENABLE_DEBUG_HOOK
@@ -882,15 +955,15 @@ argnum_error(mrb_state *mrb, mrb_int num)
 #ifndef DIRECT_THREADED
 
 #define INIT_DISPATCH for (;;) { insn = BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); switch (insn) {
-#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops ();; L_ ## insn ## _BODY:
-#define NEXT break
+#define CASE(insn,ops) case insn: pc0=pc++; FETCH_ ## ops (); pc_save = pc;
+#define NEXT goto L_END_DISPATCH
 #define JUMP NEXT
-#define END_DISPATCH }}
+#define END_DISPATCH L_END_DISPATCH:;}}
 
 #else
 
 #define INIT_DISPATCH JUMP; return mrb_nil_value();
-#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); L_ ## insn ## _BODY:
+#define CASE(insn,ops) L_ ## insn: pc0=pc++; FETCH_ ## ops (); pc_save = pc;
 #define NEXT insn=BYTECODE_DECODER(*pc); CODE_FETCH_HOOK(mrb, irep, pc, regs); goto *optable[insn]
 #define JUMP NEXT
 
@@ -899,13 +972,13 @@ argnum_error(mrb_state *mrb, mrb_int num)
 #endif
 
 MRB_API mrb_value
-mrb_vm_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
+mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep)
 {
-  mrb_irep *irep = proc->body.irep;
+  const mrb_irep *irep = proc->body.irep;
   mrb_value result;
   struct mrb_context *c = mrb->c;
   ptrdiff_t cioff = c->ci - c->cibase;
-  unsigned int nregs = irep->nregs;
+  mrb_int nregs = irep->nregs;
 
   if (!c->stack) {
     stack_init(mrb);
@@ -932,7 +1005,7 @@ static mrb_bool
 check_target_class(mrb_state *mrb)
 {
   if (!mrb->c->ci->target_class) {
-    mrb_value exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR, "no target class or module");
+    mrb_value exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR, "no target class or module");
     mrb_exc_set(mrb, exc);
     return FALSE;
   }
@@ -942,13 +1015,14 @@ check_target_class(mrb_state *mrb)
 void mrb_hash_check_kdict(mrb_state *mrb, mrb_value self);
 
 MRB_API mrb_value
-mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *pc)
+mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *pc)
 {
   /* mrb_assert(MRB_PROC_CFUNC_P(proc)) */
   const mrb_code *pc0 = pc;
-  mrb_irep *irep = proc->body.irep;
-  mrb_value *pool = irep->pool;
-  mrb_sym *syms = irep->syms;
+  const mrb_code *volatile pc_save = pc;
+  const mrb_irep *irep = proc->body.irep;
+  const mrb_pool_value *pool = irep->pool;
+  const mrb_sym *syms = irep->syms;
   mrb_code insn;
   int ai = mrb_gc_arena_save(mrb);
   struct mrb_jmpbuf *prev_jmp = mrb->jmp;
@@ -957,6 +1031,7 @@ mrb_vm_exec(mrb_state *mrb, struct RProc *proc, const mrb_code *pc)
   uint16_t b;
   uint8_t c;
   mrb_sym mid;
+  const struct mrb_irep_catch_handler *ch;
 
 #ifdef DIRECT_THREADED
   static void *optable[] = {
@@ -994,27 +1069,47 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_LOADL, BB) {
-#ifdef MRB_WORD_BOXING
-      mrb_value val = pool[b];
-#ifndef MRB_WITHOUT_FLOAT
-      if (mrb_float_p(val)) {
-        val = mrb_float_value(mrb, mrb_float(val));
-      }
-#endif
-      regs[a] = val;
+      switch (pool[b].tt) {   /* number */
+      case IREP_TT_INT32:
+        regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i32);
+        break;
+      case IREP_TT_INT64:
+#if defined(MRB_INT64)
+        regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64);
+        break;
 #else
-      regs[a] = pool[b];
+#if defined(MRB_64BIT)
+        if (INT32_MIN <= pool[b].u.i64 && pool[b].u.i64 <= INT32_MAX) {
+          regs[a] = mrb_int_value(mrb, (mrb_int)pool[b].u.i64);
+          break;
+        }
 #endif
+        {
+          mrb_value exc = mrb_exc_new_lit(mrb, E_RUNTIME_ERROR, "integer overflow");
+          mrb_exc_set(mrb, exc);
+        }
+        goto L_RAISE;
+#endif
+#ifndef MRB_NO_FLOAT
+      case IREP_TT_FLOAT:
+        regs[a] = mrb_float_value(mrb, pool[b].u.f);
+        break;
+#endif
+      default:
+        /* should not happen (tt:string) */
+        regs[a] = mrb_nil_value();
+        break;
+      }
       NEXT;
     }
 
     CASE(OP_LOADI, BB) {
-      SET_INT_VALUE(regs[a], b);
+      SET_FIXNUM_VALUE(regs[a], b);
       NEXT;
     }
 
     CASE(OP_LOADINEG, BB) {
-      SET_INT_VALUE(regs[a], -b);
+      SET_FIXNUM_VALUE(regs[a], -b);
       NEXT;
     }
 
@@ -1028,12 +1123,12 @@ RETRY_TRY_BLOCK:
     CASE(OP_LOADI_6,B) goto L_LOADI;
     CASE(OP_LOADI_7, B) {
     L_LOADI:
-      SET_INT_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0);
+      SET_FIXNUM_VALUE(regs[a], (mrb_int)insn - (mrb_int)OP_LOADI_0);
       NEXT;
     }
 
     CASE(OP_LOADI16, BS) {
-      SET_INT_VALUE(regs[a], (mrb_int)(int16_t)b);
+      SET_FIXNUM_VALUE(regs[a], (mrb_int)(int16_t)b);
       NEXT;
     }
 
@@ -1192,32 +1287,49 @@ RETRY_TRY_BLOCK:
       NEXT;
     }
 
-    CASE(OP_ONERR, S) {
-      /* check rescue stack */
-      if (mrb->c->ci->ridx == UINT16_MAX-1) {
-        mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "too many nested rescues");
-        mrb_exc_set(mrb, exc);
-        goto L_RAISE;
+    CASE(OP_JMPUW, S) {
+      CHECKPOINT_RESTORE(RBREAK_TAG_JUMP) {
+        struct RBreak *brk = (struct RBreak*)mrb->exc;
+        mrb_value target = mrb_break_value_get(brk);
+        mrb_assert(mrb_integer_p(target));
+        a = (uint32_t)mrb_integer(target);
+        mrb_assert(a >= 0 && a < irep->ilen);
       }
-      /* expand rescue stack */
-      if (mrb->c->rsize <= mrb->c->ci->ridx) {
-        if (mrb->c->rsize == 0) mrb->c->rsize = RESCUE_STACK_INIT_SIZE;
-        else {
-          mrb->c->rsize *= 2;
-          if (mrb->c->rsize <= mrb->c->ci->ridx) {
-            mrb->c->rsize = UINT16_MAX;
+      CHECKPOINT_MAIN(RBREAK_TAG_JUMP) {
+        ch = catch_handler_find(mrb, mrb->c->ci, pc, MRB_CATCH_FILTER_ENSURE);
+        if (ch) {
+          /* avoiding a jump from a catch handler into the same handler */
+          if (a < bin_to_uint16(ch->begin) || a >= bin_to_uint16(ch->end)) {
+            THROW_TAGGED_BREAK(mrb, RBREAK_TAG_JUMP, proc, mrb_fixnum_value(a));
           }
         }
-        mrb->c->rescue = (uint16_t*)mrb_realloc(mrb, mrb->c->rescue, sizeof(uint16_t)*mrb->c->rsize);
       }
-      /* push rescue stack */
-      mrb->c->rescue[mrb->c->ci->ridx++] = a;
-      NEXT;
+      CHECKPOINT_END(RBREAK_TAG_JUMP);
+
+      mrb->exc = NULL; /* clear break object */
+      pc = irep->iseq + a;
+      JUMP;
     }
 
     CASE(OP_EXCEPT, B) {
-      mrb_value exc = mrb_obj_value(mrb->exc);
-      mrb->exc = 0;
+      mrb_value exc;
+
+      if (mrb->exc == NULL) {
+        exc = mrb_nil_value();
+      }
+      else {
+        switch (mrb->exc->tt) {
+        case MRB_TT_BREAK:
+        case MRB_TT_EXCEPTION:
+          exc = mrb_obj_value(mrb->exc);
+          break;
+        default:
+          mrb_assert(!"bad mrb_type");
+          exc = mrb_nil_value();
+          break;
+        }
+        mrb->exc = NULL;
+      }
       regs[a] = exc;
       NEXT;
     }
@@ -1234,7 +1346,7 @@ RETRY_TRY_BLOCK:
         {
           mrb_value exc;
 
-          exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR,
+          exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR,
                                     "class or module required for rescue clause");
           mrb_exc_set(mrb, exc);
           goto L_RAISE;
@@ -1245,74 +1357,19 @@ RETRY_TRY_BLOCK:
       NEXT;
     }
 
-    CASE(OP_POPERR, B) {
-      mrb->c->ci->ridx -= a;
-      NEXT;
-    }
-
-    CASE(OP_RAISE, B) {
-      mrb_exc_set(mrb, regs[a]);
-      goto L_RAISE;
-    }
-
-    CASE(OP_EPUSH, B) {
-      struct RProc *p;
-
-      p = mrb_closure_new(mrb, irep->reps[a]);
-      /* check ensure stack */
-      if (mrb->c->eidx == UINT16_MAX-1) {
-        mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "too many nested ensures");
-        mrb_exc_set(mrb, exc);
-        goto L_RAISE;
+    CASE(OP_RAISEIF, B) {
+      mrb_value exc = regs[a];
+      if (mrb_break_p(exc)) {
+        mrb->exc = mrb_obj_ptr(exc);
+        goto L_BREAK;
       }
-      /* expand ensure stack */
-      if (mrb->c->esize <= mrb->c->eidx+1) {
-        if (mrb->c->esize == 0) mrb->c->esize = ENSURE_STACK_INIT_SIZE;
-        else {
-          mrb->c->esize *= 2;
-          if (mrb->c->esize <= mrb->c->eidx) {
-            mrb->c->esize = UINT16_MAX;
-          }
-        }
-        mrb->c->ensure = (struct RProc**)mrb_realloc(mrb, mrb->c->ensure, sizeof(struct RProc*)*mrb->c->esize);
+      mrb_exc_set(mrb, exc);
+      if (mrb->exc) {
+        goto L_RAISE;
       }
-      /* push ensure stack */
-      mrb->c->ensure[mrb->c->eidx++] = p;
-      mrb->c->ensure[mrb->c->eidx] = NULL;
-      mrb_gc_arena_restore(mrb, ai);
       NEXT;
     }
 
-    CASE(OP_EPOP, B) {
-      mrb_callinfo *ci = mrb->c->ci;
-      unsigned int n, epos = ci->epos;
-      mrb_value self = regs[0];
-      struct RClass *target_class = ci->target_class;
-
-      if (mrb->c->eidx <= epos) {
-        NEXT;
-      }
-
-      if (a > (int)mrb->c->eidx - epos)
-        a = mrb->c->eidx - epos;
-      for (n=0; n<a; n++) {
-        int nregs = irep->nregs;
-
-        proc = mrb->c->ensure[epos+n];
-        mrb->c->ensure[epos+n] = NULL;
-        if (proc == NULL) continue;
-        irep = proc->body.irep;
-        ci = cipush(mrb, pc, nregs, nregs, target_class, proc, ci->mid, 0);
-        mrb_stack_extend(mrb, irep->nregs);
-        regs[0] = self;
-        pc = irep->iseq;
-      }
-      pool = irep->pool;
-      syms = irep->syms;
-      mrb->c->eidx = epos;
-      JUMP;
-    }
-
     CASE(OP_SENDV, BB) {
       c = CALL_MAXARGS;
       goto L_SEND;
@@ -1344,8 +1401,8 @@ RETRY_TRY_BLOCK:
     mid = syms[b];
     L_SENDB_SYM:
     {
-      int argc = (c == CALL_MAXARGS) ? -1 : c;
-      int bidx = (argc < 0) ? a+2 : a+c+1;
+      mrb_int argc = (c == CALL_MAXARGS) ? -1 : c;
+      mrb_int bidx = (argc < 0) ? a+2 : a+c+1;
       mrb_method_t m;
       struct RClass *cls;
       mrb_callinfo *ci = mrb->c->ci;
@@ -1356,15 +1413,15 @@ RETRY_TRY_BLOCK:
       recv = regs[a];
       blk = regs[bidx];
       if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) {
-        blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, "Proc", "to_proc");
-        /* The stack might have been reallocated during mrb_convert_type(),
+        blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc));
+        /* The stack might have been reallocated during mrb_type_convert(),
            see #3622 */
         regs[bidx] = blk;
       }
       cls = mrb_class(mrb, recv);
       m = mrb_method_search_vm(mrb, &cls, mid);
       if (MRB_METHOD_UNDEF_P(m)) {
-        mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
+        mrb_sym missing = MRB_SYM(method_missing);
         m = mrb_method_search_vm(mrb, &cls, missing);
         if (MRB_METHOD_UNDEF_P(m) || (missing == mrb->c->ci->mid && mrb_obj_eq(mrb, regs[0], recv))) {
           mrb_value args = (argc < 0) ? regs[a+1] : mrb_ary_new_from_values(mrb, c, regs+a+1);
@@ -1479,7 +1536,7 @@ RETRY_TRY_BLOCK:
           mrb->c->stack[0] = mrb_nil_value();
           a = 0;
           c = OP_R_NORMAL;
-          goto L_OP_RETURN_BODY;
+          goto L_RETURN;
         }
         pool = irep->pool;
         syms = irep->syms;
@@ -1501,13 +1558,13 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_SUPER, BB) {
-      int argc = (b == CALL_MAXARGS) ? -1 : b;
+      mrb_int argc = (b == CALL_MAXARGS) ? -1 : b;
       int bidx = (argc < 0) ? a+2 : a+b+1;
       mrb_method_t m;
       struct RClass *cls;
       mrb_callinfo *ci = mrb->c->ci;
       mrb_value recv, blk;
-      struct RProc *p = ci->proc;
+      const struct RProc *p = ci->proc;
       mrb_sym mid = ci->mid;
       struct RClass* target_class = MRB_PROC_TARGET_CLASS(p);
 
@@ -1517,37 +1574,37 @@ RETRY_TRY_BLOCK:
       mrb_assert(bidx < irep->nregs);
 
       if (mid == 0 || !target_class) {
-        mrb_value exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
+        mrb_value exc = mrb_exc_new_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
         mrb_exc_set(mrb, exc);
         goto L_RAISE;
       }
       if (target_class->tt == MRB_TT_MODULE) {
         target_class = ci->target_class;
         if (target_class->tt != MRB_TT_ICLASS) {
-          mrb_value exc = mrb_exc_new_str_lit(mrb, E_RUNTIME_ERROR, "superclass info lost [mruby limitations]");
+          mrb_value exc = mrb_exc_new_lit(mrb, E_RUNTIME_ERROR, "superclass info lost [mruby limitations]");
           mrb_exc_set(mrb, exc);
           goto L_RAISE;
         }
       }
       recv = regs[0];
       if (!mrb_obj_is_kind_of(mrb, recv, target_class)) {
-        mrb_value exc = mrb_exc_new_str_lit(mrb, E_TYPE_ERROR,
+        mrb_value exc = mrb_exc_new_lit(mrb, E_TYPE_ERROR,
                                             "self has wrong type to call super in this context");
         mrb_exc_set(mrb, exc);
         goto L_RAISE;
       }
       blk = regs[bidx];
       if (!mrb_nil_p(blk) && !mrb_proc_p(blk)) {
-        blk = mrb_convert_type(mrb, blk, MRB_TT_PROC, "Proc", "to_proc");
+        blk = mrb_type_convert(mrb, blk, MRB_TT_PROC, MRB_SYM(to_proc));
         /* The stack or ci stack might have been reallocated during
-           mrb_convert_type(), see #3622 and #3784 */
+           mrb_type_convert(), see #3622 and #3784 */
         regs[bidx] = blk;
         ci = mrb->c->ci;
       }
       cls = target_class->super;
       m = mrb_method_search_vm(mrb, &cls, mid);
       if (MRB_METHOD_UNDEF_P(m)) {
-        mrb_sym missing = mrb_intern_lit(mrb, "method_missing");
+        mrb_sym missing = MRB_SYM(method_missing);
 
         if (mid != missing) {
           cls = mrb_class(mrb, recv);
@@ -1586,6 +1643,7 @@ RETRY_TRY_BLOCK:
         mrb_gc_arena_restore(mrb, ai);
         if (mrb->exc) goto L_RAISE;
         ci = mrb->c->ci;
+        mrb_assert(!mrb_break_p(v));
         if (!ci->target_class) { /* return from context modifying method (resume/yield) */
           if (ci->acc == CI_ACC_RESUMED) {
             mrb->jmp = prev_jmp;
@@ -1620,18 +1678,18 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_ARGARY, BS) {
-      int m1 = (b>>11)&0x3f;
-      int r  = (b>>10)&0x1;
-      int m2 = (b>>5)&0x1f;
-      int kd = (b>>4)&0x1;
-      int lv = (b>>0)&0xf;
+      mrb_int m1 = (b>>11)&0x3f;
+      mrb_int r  = (b>>10)&0x1;
+      mrb_int m2 = (b>>5)&0x1f;
+      mrb_int kd = (b>>4)&0x1;
+      mrb_int lv = (b>>0)&0xf;
       mrb_value *stack;
 
       if (mrb->c->ci->mid == 0 || mrb->c->ci->target_class == NULL) {
         mrb_value exc;
 
       L_NOSUPER:
-        exc = mrb_exc_new_str_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
+        exc = mrb_exc_new_lit(mrb, E_NOMETHOD_ERROR, "super called outside of method");
         mrb_exc_set(mrb, exc);
         goto L_RAISE;
       }
@@ -1649,13 +1707,13 @@ RETRY_TRY_BLOCK:
       else {
         mrb_value *pp = NULL;
         struct RArray *rest;
-        int len = 0;
+        mrb_int len = 0;
 
         if (mrb_array_p(stack[m1])) {
           struct RArray *ary = mrb_ary_ptr(stack[m1]);
 
           pp = ARY_PTR(ary);
-          len = (int)ARY_LEN(ary);
+          len = ARY_LEN(ary);
         }
         regs[a] = mrb_ary_new_capa(mrb, m1+len+m2+kd);
         rest = mrb_ary_ptr(regs[a]);
@@ -1679,22 +1737,22 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_ENTER, W) {
-      int m1 = MRB_ASPEC_REQ(a);
-      int o  = MRB_ASPEC_OPT(a);
-      int r  = MRB_ASPEC_REST(a);
-      int m2 = MRB_ASPEC_POST(a);
-      int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0;
+      mrb_int m1 = MRB_ASPEC_REQ(a);
+      mrb_int o  = MRB_ASPEC_OPT(a);
+      mrb_int r  = MRB_ASPEC_REST(a);
+      mrb_int m2 = MRB_ASPEC_POST(a);
+      mrb_int kd = (MRB_ASPEC_KEY(a) > 0 || MRB_ASPEC_KDICT(a))? 1 : 0;
       /* unused
       int b  = MRB_ASPEC_BLOCK(a);
       */
-      int argc = mrb->c->ci->argc;
+      mrb_int argc = mrb->c->ci->argc;
       mrb_value *argv = regs+1;
       mrb_value * const argv0 = argv;
-      int const len = m1 + o + r + m2;
-      int const blk_pos = len + kd + 1;
+      mrb_int const len = m1 + o + r + m2;
+      mrb_int const blk_pos = len + kd + 1;
       mrb_value *blk = &argv[argc < 0 ? 1 : argc];
-      mrb_value kdict;
-      int kargs = kd;
+      mrb_value kdict = mrb_nil_value();
+      mrb_int kargs = kd;
 
       /* arguments is passed with Array */
       if (argc < 0) {
@@ -1746,7 +1804,7 @@ RETRY_TRY_BLOCK:
 
       /* no rest arguments */
       if (argc-kargs < len) {
-        int mlen = m2;
+        mrb_int mlen = m2;
         if (argc < m1+m2) {
           mlen = m1 < argc ? argc - m1 : 0;
         }
@@ -1754,7 +1812,7 @@ RETRY_TRY_BLOCK:
         if (kd) regs[len + 1] = kdict;
 
         /* copy mandatory and optional arguments */
-        if (argv0 != argv) {
+        if (argv0 != argv && argv) {
           value_move(&regs[1], argv, argc-mlen); /* m1 + o */
         }
         if (argc < m1) {
@@ -1776,7 +1834,7 @@ RETRY_TRY_BLOCK:
           pc += (argc - kargs - m1 - m2)*3;
       }
       else {
-        int rnum = 0;
+        mrb_int rnum = 0;
         if (argv0 != argv) {
           regs[blk_pos] = *blk; /* move block */
           if (kd) regs[len + 1] = kdict;
@@ -1862,13 +1920,7 @@ RETRY_TRY_BLOCK:
     c = OP_R_NORMAL;
     L_RETURN:
     {
-       mrb_callinfo *ci;
-
-#define ecall_adjust() do {\
-  ptrdiff_t cioff = ci - mrb->c->cibase;\
-  ecall(mrb);\
-  ci = mrb->c->cibase + cioff;\
-} while (0)
+      mrb_callinfo *ci;
 
       ci = mrb->c->ci;
       if (ci->mid) {
@@ -1896,17 +1948,20 @@ RETRY_TRY_BLOCK:
       L_RAISE:
         ci0 = ci = mrb->c->ci;
         if (ci == mrb->c->cibase) {
-          if (ci->ridx == 0) goto L_FTOP;
-          goto L_RESCUE;
+          ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL);
+          if (ch == NULL) goto L_FTOP;
+          goto L_CATCH;
         }
-        while (ci[0].ridx == ci[-1].ridx) {
+        while ((ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL)) == NULL) {
           ci = cipop(mrb);
           if (ci[1].acc == CI_ACC_SKIP && prev_jmp) {
             mrb->jmp = prev_jmp;
             MRB_THROW(prev_jmp);
           }
+          pc = ci[1].pc;
           if (ci == mrb->c->cibase) {
-            if (ci->ridx == 0) {
+            ch = catch_handler_find(mrb, ci, pc, MRB_CATCH_FILTER_ALL);
+            if (ch == NULL) {
             L_FTOP:             /* fiber top */
               if (mrb->c == mrb->root_c) {
                 mrb->c->stack = mrb->c->stbase;
@@ -1915,9 +1970,6 @@ RETRY_TRY_BLOCK:
               else {
                 struct mrb_context *c = mrb->c;
 
-                while (c->eidx > ci->epos) {
-                  ecall_adjust();
-                }
                 c->status = MRB_FIBER_TERMINATED;
                 mrb->c = c->prev;
                 c->prev = NULL;
@@ -1926,15 +1978,13 @@ RETRY_TRY_BLOCK:
             }
             break;
           }
-          /* call ensure only when we skip this callinfo */
-          if (ci[0].ridx == ci[-1].ridx) {
-            while (mrb->c->eidx > ci->epos) {
-              ecall_adjust();
-            }
-          }
         }
-      L_RESCUE:
-        if (ci->ridx == 0) goto L_STOP;
+      L_CATCH:
+        if (ch == NULL) goto L_STOP;
+        if (FALSE) {
+        L_CATCH_TAGGED_BREAK: /* from THROW_TAGGED_BREAK() or UNWIND_ENSURE() */
+          ci = ci0 = mrb->c->ci;
+        }
         proc = ci->proc;
         irep = proc->body.irep;
         pool = irep->pool;
@@ -1943,12 +1993,11 @@ RETRY_TRY_BLOCK:
           mrb->c->stack = ci[1].stackent;
         }
         mrb_stack_extend(mrb, irep->nregs);
-        pc = irep->iseq+mrb->c->rescue[--ci->ridx];
+        pc = irep->iseq + bin_to_uint16(ch->target);
       }
       else {
-        int acc;
+        mrb_int acc;
         mrb_value v;
-        struct RProc *dst;
 
         ci = mrb->c->ci;
         v = regs[a];
@@ -1957,7 +2006,9 @@ RETRY_TRY_BLOCK:
         case OP_R_RETURN:
           /* Fall through to OP_R_NORMAL otherwise */
           if (ci->acc >=0 && MRB_PROC_ENV_P(proc) && !MRB_PROC_STRICT_P(proc)) {
-            mrb_callinfo *cibase = mrb->c->cibase;
+            const struct RProc *dst;
+            mrb_callinfo *cibase;
+            cibase = mrb->c->cibase;
             dst = top_proc(mrb, proc);
 
             if (MRB_PROC_ENV_P(dst)) {
@@ -1968,37 +2019,58 @@ RETRY_TRY_BLOCK:
                 goto L_RAISE;
               }
             }
+            /* check jump destination */
             while (cibase <= ci && ci->proc != dst) {
-              if (ci->acc < 0) {
+              if (ci->acc < 0) { /* jump cross C boudary */
                 localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
                 goto L_RAISE;
               }
               ci--;
             }
-            if (ci <= cibase) {
+            if (ci <= cibase) { /* no jump destination */
               localjump_error(mrb, LOCALJUMP_ERROR_RETURN);
               goto L_RAISE;
             }
+            ci = mrb->c->ci;
+            while (cibase <= ci && ci->proc != dst) {
+              CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_BLOCK) {
+                cibase = mrb->c->cibase;
+                dst = top_proc(mrb, proc);
+              }
+              CHECKPOINT_MAIN(RBREAK_TAG_RETURN_BLOCK) {
+                UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN_BLOCK, proc, v);
+              }
+              CHECKPOINT_END(RBREAK_TAG_RETURN_BLOCK);
+              pc = ci->pc;
+              ci = cipop(mrb);
+            }
+            proc = ci->proc;
+            mrb->exc = NULL; /* clear break object */
             break;
           }
           /* fallthrough */
         case OP_R_NORMAL:
         NORMAL_RETURN:
           if (ci == mrb->c->cibase) {
-            struct mrb_context *c = mrb->c;
+            struct mrb_context *c;
+            c = mrb->c;
 
             if (!c->prev) { /* toplevel return */
               regs[irep->nlocals] = v;
-              goto L_STOP;
+              goto CHECKPOINT_LABEL_MAKE(RBREAK_TAG_STOP);
             }
             if (c->prev->ci == c->prev->cibase) {
-              mrb_value exc = mrb_exc_new_str_lit(mrb, E_FIBER_ERROR, "double resume");
+              mrb_value exc = mrb_exc_new_lit(mrb, E_FIBER_ERROR, "double resume");
               mrb_exc_set(mrb, exc);
               goto L_RAISE;
             }
-            while (c->eidx > 0) {
-              ecall(mrb);
+            CHECKPOINT_RESTORE(RBREAK_TAG_RETURN_TOPLEVEL) {
+              c = mrb->c;
+            }
+            CHECKPOINT_MAIN(RBREAK_TAG_RETURN_TOPLEVEL) {
+              UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN_TOPLEVEL, proc, v);
             }
+            CHECKPOINT_END(RBREAK_TAG_RETURN_TOPLEVEL);
             /* automatic yield at the end */
             c->status = MRB_FIBER_TERMINATED;
             mrb->c = c->prev;
@@ -2006,6 +2078,14 @@ RETRY_TRY_BLOCK:
             mrb->c->status = MRB_FIBER_RUNNING;
             ci = mrb->c->ci;
           }
+          CHECKPOINT_RESTORE(RBREAK_TAG_RETURN) {
+            /* do nothing */
+          }
+          CHECKPOINT_MAIN(RBREAK_TAG_RETURN) {
+            UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_RETURN, proc, v);
+          }
+          CHECKPOINT_END(RBREAK_TAG_RETURN);
+          mrb->exc = NULL; /* clear break object */
           break;
         case OP_R_BREAK:
           if (MRB_PROC_STRICT_P(proc)) goto NORMAL_RETURN;
@@ -2013,7 +2093,7 @@ RETRY_TRY_BLOCK:
             mrb_value exc;
 
           L_BREAK_ERROR:
-            exc = mrb_exc_new_str_lit(mrb, E_LOCALJUMP_ERROR,
+            exc = mrb_exc_new_lit(mrb, E_LOCALJUMP_ERROR,
                                       "break from proc-closure");
             mrb_exc_set(mrb, exc);
             goto L_RAISE;
@@ -2028,9 +2108,13 @@ RETRY_TRY_BLOCK:
               goto L_BREAK_ERROR;
             }
           }
-          while (mrb->c->eidx > mrb->c->ci->epos) {
-            ecall_adjust();
+          CHECKPOINT_RESTORE(RBREAK_TAG_BREAK) {
+            /* do nothing */
+          }
+          CHECKPOINT_MAIN(RBREAK_TAG_BREAK) {
+            UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK, proc, v);
           }
+          CHECKPOINT_END(RBREAK_TAG_BREAK);
           /* break from fiber block */
           if (ci == mrb->c->cibase && ci->pc) {
             struct mrb_context *c = mrb->c;
@@ -2040,45 +2124,64 @@ RETRY_TRY_BLOCK:
             ci = mrb->c->ci;
           }
           if (ci->acc < 0) {
+            ci = cipop(mrb);
             mrb_gc_arena_restore(mrb, ai);
             mrb->c->vmexec = FALSE;
-            mrb->exc = (struct RObject*)break_new(mrb, proc, v);
+            mrb->exc = (struct RObject*)break_new(mrb, RBREAK_TAG_BREAK, proc, v);
             mrb->jmp = prev_jmp;
             MRB_THROW(prev_jmp);
           }
           if (FALSE) {
+            struct RBreak *brk;
+
           L_BREAK:
-            v = mrb_break_value_get((struct RBreak*)mrb->exc);
-            proc = mrb_break_proc_get((struct RBreak*)mrb->exc);
-            mrb->exc = NULL;
+            brk = (struct RBreak*)mrb->exc;
+            proc = mrb_break_proc_get(brk);
+            v = mrb_break_value_get(brk);
             ci = mrb->c->ci;
+
+            switch (mrb_break_tag_get(brk)) {
+#define DISPATCH_CHECKPOINTS(n, i) case n: goto CHECKPOINT_LABEL_MAKE(n);
+              RBREAK_TAG_FOREACH(DISPATCH_CHECKPOINTS)
+#undef DISPATCH_CHECKPOINTS
+              default:
+                mrb_assert(!"wrong break tag");
+            }
           }
           mrb->c->stack = ci->stackent;
-          proc = proc->upper;
-          while (mrb->c->cibase < ci &&  ci[-1].proc != proc) {
+          while (mrb->c->cibase < ci && ci[-1].proc != proc->upper) {
             if (ci[-1].acc == CI_ACC_SKIP) {
-              while (ci < mrb->c->ci) {
-                cipop(mrb);
-              }
               goto L_BREAK_ERROR;
             }
-            ci--;
+            CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_UPPER) {
+              /* do nothing */
+            }
+            CHECKPOINT_MAIN(RBREAK_TAG_BREAK_UPPER) {
+              UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK_UPPER, proc, v);
+            }
+            CHECKPOINT_END(RBREAK_TAG_BREAK_UPPER);
+            pc = ci->pc;
+            ci = cipop(mrb);
+          }
+          CHECKPOINT_RESTORE(RBREAK_TAG_BREAK_INTARGET) {
+            /* do nothing */
           }
+          CHECKPOINT_MAIN(RBREAK_TAG_BREAK_INTARGET) {
+            UNWIND_ENSURE(mrb, ci, pc, RBREAK_TAG_BREAK_INTARGET, proc, v);
+          }
+          CHECKPOINT_END(RBREAK_TAG_BREAK_INTARGET);
           if (ci == mrb->c->cibase) {
             goto L_BREAK_ERROR;
           }
+          mrb->exc = NULL; /* clear break object */
           break;
         default:
           /* cannot happen */
           break;
         }
-        while (ci < mrb->c->ci) {
-          cipop(mrb);
-        }
-        ci[0].ridx = ci[-1].ridx;
-        while (mrb->c->eidx > ci->epos) {
-          ecall_adjust();
-        }
+        mrb_assert(ci == mrb->c->ci);
+        mrb_assert(mrb->exc == NULL);
+
         if (mrb->c->vmexec && !ci->target_class) {
           mrb_gc_arena_restore(mrb, ai);
           mrb->c->vmexec = FALSE;
@@ -2142,23 +2245,23 @@ RETRY_TRY_BLOCK:
     OP_MATH_CASE_STRING_##op_name();                                        \
     default:                                                                \
       c = 1;                                                                \
-      mid = mrb_intern_lit(mrb, MRB_STRINGIZE(OP_MATH_OP_##op_name));       \
+      mid = MRB_QSYM(op_name);                                              \
       goto L_SEND_SYM;                                                      \
   }                                                                         \
   NEXT;
 #define OP_MATH_CASE_FIXNUM(op_name)                                        \
-  case TYPES2(MRB_TT_FIXNUM, MRB_TT_FIXNUM):                                \
+  case TYPES2(MRB_TT_INTEGER, MRB_TT_INTEGER):                              \
     {                                                                       \
-      mrb_int x = mrb_fixnum(regs[a]), y = mrb_fixnum(regs[a+1]), z;        \
+      mrb_int x = mrb_integer(regs[a]), y = mrb_integer(regs[a+1]), z;      \
       if (mrb_int_##op_name##_overflow(x, y, &z))                           \
         OP_MATH_OVERFLOW_INT(op_name, x, y, z);                             \
       else                                                                  \
-        SET_INT_VALUE(regs[a], z);                                          \
+        SET_INT_VALUE(mrb,regs[a], z);                                      \
     }                                                                       \
     break
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
 #define OP_MATH_CASE_FLOAT(op_name, t1, t2) (void)0
-#define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(regs[a], z)
+#define OP_MATH_OVERFLOW_INT(op_name, x, y, z) SET_INT_VALUE(mrb,regs[a], z)
 #else
 #define OP_MATH_CASE_FLOAT(op_name, t1, t2)                                     \
   case TYPES2(OP_MATH_TT_##t1, OP_MATH_TT_##t2):                                \
@@ -2180,7 +2283,7 @@ RETRY_TRY_BLOCK:
 #define OP_MATH_OP_add +
 #define OP_MATH_OP_sub -
 #define OP_MATH_OP_mul *
-#define OP_MATH_TT_fixnum MRB_TT_FIXNUM
+#define OP_MATH_TT_fixnum MRB_TT_INTEGER
 #define OP_MATH_TT_float  MRB_TT_FLOAT
 
     CASE(OP_ADD, B) {
@@ -2196,31 +2299,30 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_DIV, B) {
-#ifndef MRB_WITHOUT_FLOAT
-      double x, y, f;
+      mrb_int mrb_num_div_int(mrb_state *mrb, mrb_int x, mrb_int y);
+#ifndef MRB_NO_FLOAT
+      mrb_float mrb_num_div_flo(mrb_state *mrb, mrb_float x, mrb_float y);
+      mrb_float x, y, f;
 #endif
 
       /* need to check if op is overridden */
       switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {
-      case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):
-#ifdef MRB_WITHOUT_FLOAT
+      case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):
         {
-          mrb_int x = mrb_fixnum(regs[a]);
-          mrb_int y = mrb_fixnum(regs[a+1]);
-          SET_INT_VALUE(regs[a], y ? x / y : 0);
+          mrb_int x = mrb_integer(regs[a]);
+          mrb_int y = mrb_integer(regs[a+1]);
+          mrb_int div = mrb_num_div_int(mrb, x, y);
+          SET_INT_VALUE(mrb, regs[a], div);
         }
-        break;
-#else
-        x = (mrb_float)mrb_fixnum(regs[a]);
-        y = (mrb_float)mrb_fixnum(regs[a+1]);
-        break;
-      case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):
-        x = (mrb_float)mrb_fixnum(regs[a]);
+        NEXT;
+#ifndef MRB_NO_FLOAT
+      case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):
+        x = (mrb_float)mrb_integer(regs[a]);
         y = mrb_float(regs[a+1]);
         break;
-      case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):
+      case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):
         x = mrb_float(regs[a]);
-        y = (mrb_float)mrb_fixnum(regs[a+1]);
+        y = (mrb_float)mrb_integer(regs[a+1]);
         break;
       case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):
         x = mrb_float(regs[a]);
@@ -2229,19 +2331,12 @@ RETRY_TRY_BLOCK:
 #endif
       default:
         c = 1;
-        mid = mrb_intern_lit(mrb, "/");
+        mid = MRB_QSYM(div);
         goto L_SEND_SYM;
       }
 
-#ifndef MRB_WITHOUT_FLOAT
-      if (y == 0) {
-        if (x > 0) f = INFINITY;
-        else if (x < 0) f = -INFINITY;
-        else /* if (x == 0) */ f = NAN;
-      }
-      else {
-        f = x / y;
-      }
+#ifndef MRB_NO_FLOAT
+      f = mrb_num_div_flo(mrb, x, y);
       SET_FLOAT_VALUE(mrb, regs[a], f);
 #endif
       NEXT;
@@ -2253,23 +2348,23 @@ RETRY_TRY_BLOCK:
     OP_MATHI_CASE_FIXNUM(op_name);                                          \
     OP_MATHI_CASE_FLOAT(op_name);                                           \
     default:                                                                \
-      SET_INT_VALUE(regs[a+1], b);                                          \
+      SET_INT_VALUE(mrb,regs[a+1], b);                                      \
       c = 1;                                                                \
-      mid = mrb_intern_lit(mrb, MRB_STRINGIZE(OP_MATH_OP_##op_name));       \
+      mid = MRB_QSYM(op_name);                                              \
       goto L_SEND_SYM;                                                      \
   }                                                                         \
   NEXT;
 #define OP_MATHI_CASE_FIXNUM(op_name)                                       \
-  case MRB_TT_FIXNUM:                                                       \
+  case MRB_TT_INTEGER:                                                      \
     {                                                                       \
-      mrb_int x = mrb_fixnum(regs[a]), y = (mrb_int)b, z;                   \
+      mrb_int x = mrb_integer(regs[a]), y = (mrb_int)b, z;                  \
       if (mrb_int_##op_name##_overflow(x, y, &z))                           \
         OP_MATH_OVERFLOW_INT(op_name, x, y, z);                             \
       else                                                                  \
-        SET_INT_VALUE(regs[a], z);                                          \
+        SET_INT_VALUE(mrb,regs[a], z);                                      \
     }                                                                       \
     break
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
 #define OP_MATHI_CASE_FLOAT(op_name) (void)0
 #else
 #define OP_MATHI_CASE_FLOAT(op_name)                                        \
@@ -2291,17 +2386,17 @@ RETRY_TRY_BLOCK:
 
 #define OP_CMP_BODY(op,v1,v2) (v1(regs[a]) op v2(regs[a+1]))
 
-#ifdef MRB_WITHOUT_FLOAT
-#define OP_CMP(op) do {\
+#ifdef MRB_NO_FLOAT
+#define OP_CMP(op,sym) do {\
   int result;\
   /* need to check if - is overridden */\
   switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
-  case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
+  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
     result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\
     break;\
   default:\
     c = 1;\
-    mid = mrb_intern_lit(mrb, # op);\
+    mid = MRB_QSYM(sym);\
     goto L_SEND_SYM;\
   }\
   if (result) {\
@@ -2312,17 +2407,17 @@ RETRY_TRY_BLOCK:
   }\
 } while(0)
 #else
-#define OP_CMP(op) do {\
+#define OP_CMP(op, sym) do {\
   int result;\
   /* need to check if - is overridden */\
   switch (TYPES2(mrb_type(regs[a]),mrb_type(regs[a+1]))) {\
-  case TYPES2(MRB_TT_FIXNUM,MRB_TT_FIXNUM):\
+  case TYPES2(MRB_TT_INTEGER,MRB_TT_INTEGER):\
     result = OP_CMP_BODY(op,mrb_fixnum,mrb_fixnum);\
     break;\
-  case TYPES2(MRB_TT_FIXNUM,MRB_TT_FLOAT):\
+  case TYPES2(MRB_TT_INTEGER,MRB_TT_FLOAT):\
     result = OP_CMP_BODY(op,mrb_fixnum,mrb_float);\
     break;\
-  case TYPES2(MRB_TT_FLOAT,MRB_TT_FIXNUM):\
+  case TYPES2(MRB_TT_FLOAT,MRB_TT_INTEGER):\
     result = OP_CMP_BODY(op,mrb_float,mrb_fixnum);\
     break;\
   case TYPES2(MRB_TT_FLOAT,MRB_TT_FLOAT):\
@@ -2330,7 +2425,7 @@ RETRY_TRY_BLOCK:
     break;\
   default:\
     c = 1;\
-    mid = mrb_intern_lit(mrb, # op);\
+    mid = MRB_QSYM(sym);\
     goto L_SEND_SYM;\
   }\
   if (result) {\
@@ -2347,28 +2442,28 @@ RETRY_TRY_BLOCK:
         SET_TRUE_VALUE(regs[a]);
       }
       else {
-        OP_CMP(==);
+        OP_CMP(==,eq);
       }
       NEXT;
     }
 
     CASE(OP_LT, B) {
-      OP_CMP(<);
+      OP_CMP(<,lt);
       NEXT;
     }
 
     CASE(OP_LE, B) {
-      OP_CMP(<=);
+      OP_CMP(<=,le);
       NEXT;
     }
 
     CASE(OP_GT, B) {
-      OP_CMP(>);
+      OP_CMP(>,gt);
       NEXT;
     }
 
     CASE(OP_GE, B) {
-      OP_CMP(>=);
+      OP_CMP(>=,ge);
       NEXT;
     }
 
@@ -2480,9 +2575,13 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_STRING, BB) {
-      mrb_value str = mrb_str_dup(mrb, pool[b]);
-
-      regs[a] = str;
+      size_t len = pool[b].tt >> 2;
+      if (pool[b].tt & IREP_TT_SFLAG) {
+        regs[a] = mrb_str_new_static(mrb, pool[b].u.str, len);
+      }
+      else {
+        regs[a] = mrb_str_new(mrb, pool[b].u.str, len);
+      }
       mrb_gc_arena_restore(mrb, ai);
       NEXT;
     }
@@ -2530,7 +2629,7 @@ RETRY_TRY_BLOCK:
     L_MAKE_LAMBDA:
     {
       struct RProc *p;
-      mrb_irep *nirep = irep->reps[b];
+      const mrb_irep *nirep = irep->reps[b];
 
       if (c & OP_L_CAPTURE) {
         p = mrb_closure_new(mrb, nirep);
@@ -2581,6 +2680,7 @@ RETRY_TRY_BLOCK:
       super = regs[a+1];
       if (mrb_nil_p(base)) {
         baseclass = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+        if (!baseclass) baseclass = mrb->object_class;
         base = mrb_obj_value(baseclass);
       }
       c = mrb_vm_define_class(mrb, base, super, id);
@@ -2597,6 +2697,7 @@ RETRY_TRY_BLOCK:
       base = regs[a];
       if (mrb_nil_p(base)) {
         baseclass = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+        if (!baseclass) baseclass = mrb->object_class;
         base = mrb_obj_value(baseclass);
       }
       cls = mrb_vm_define_module(mrb, base, id);
@@ -2608,7 +2709,7 @@ RETRY_TRY_BLOCK:
     CASE(OP_EXEC, BB) {
       mrb_value recv = regs[a];
       struct RProc *p;
-      mrb_irep *nirep = irep->reps[b];
+      const mrb_irep *nirep = irep->reps[b];
 
       /* prepare closure */
       p = mrb_proc_new(mrb, nirep);
@@ -2684,56 +2785,30 @@ RETRY_TRY_BLOCK:
     }
 
     CASE(OP_ERR, B) {
-      mrb_value msg = mrb_str_dup(mrb, pool[a]);
+      size_t len = pool[a].tt >> 2;
       mrb_value exc;
 
-      exc = mrb_exc_new_str(mrb, E_LOCALJUMP_ERROR, msg);
+      mrb_assert((pool[a].tt&IREP_TT_NFLAG)==0);
+      exc = mrb_exc_new(mrb, E_LOCALJUMP_ERROR, pool[a].u.str, len);
       ERR_PC_SET(mrb);
       mrb_exc_set(mrb, exc);
       goto L_RAISE;
     }
 
-    CASE(OP_EXT1, Z) {
-      insn = READ_B();
-      switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _1(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      pc--;
-      NEXT;
-    }
-    CASE(OP_EXT2, Z) {
-      insn = READ_B();
-      switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _2(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      pc--;
-      NEXT;
-    }
-    CASE(OP_EXT3, Z) {
-      uint8_t insn = READ_B();
-      switch (insn) {
-#define OPCODE(insn,ops) case OP_ ## insn: FETCH_ ## ops ## _3(); goto L_OP_ ## insn ## _BODY;
-#include "mruby/ops.h"
-#undef OPCODE
-      }
-      pc--;
-      NEXT;
-    }
-
     CASE(OP_STOP, Z) {
       /*        stop VM */
-    L_STOP:
-      while (mrb->c->eidx > 0) {
-        ecall(mrb);
+      CHECKPOINT_RESTORE(RBREAK_TAG_STOP) {
+        /* do nothing */
+      }
+      CHECKPOINT_MAIN(RBREAK_TAG_STOP) {
+        UNWIND_ENSURE(mrb, mrb->c->ci, pc, RBREAK_TAG_STOP, proc, mrb_nil_value());
       }
-      mrb->c->cibase->ridx = 0;
+      CHECKPOINT_END(RBREAK_TAG_STOP);
+    L_STOP:
       ERR_PC_CLR(mrb);
       mrb->jmp = prev_jmp;
       if (mrb->exc) {
+        mrb_assert(mrb->exc->tt == MRB_TT_EXCEPTION);
         return mrb_obj_value(mrb->exc);
       }
       return regs[irep->nlocals];
@@ -2743,14 +2818,19 @@ RETRY_TRY_BLOCK:
 #undef regs
   }
   MRB_CATCH(&c_jmp) {
+    mrb_callinfo *ci = mrb->c->ci;
+    while (ci > mrb->c->cibase && ci->acc == CI_ACC_DIRECT) {
+      ci = cipop(mrb);
+    }
     exc_catched = TRUE;
+    pc = pc_save;
     goto RETRY_TRY_BLOCK;
   }
   MRB_END_EXC(&c_jmp);
 }
 
 static mrb_value
-mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
+mrb_run(mrb_state *mrb, const struct RProc *proc, mrb_value self)
 {
   if (mrb->c->ci->argc < 0) {
     return mrb_vm_run(mrb, proc, self, 3); /* receiver, args and block) */
@@ -2761,7 +2841,7 @@ mrb_run(mrb_state *mrb, struct RProc *proc, mrb_value self)
 }
 
 MRB_API mrb_value
-mrb_top_run(mrb_state *mrb, struct RProc *proc, mrb_value self, unsigned int stack_keep)
+mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep)
 {
   mrb_value v;
 
diff --git a/examples/targets/build_config_ArduinoDue.rb b/target/ArduinoDue.rb
index 09646a700..5859f8508 100644
--- a/examples/targets/build_config_ArduinoDue.rb
+++ b/target/ArduinoDue.rb
@@ -1,19 +1,3 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-end
-
 # Cross Compiling configuration for Arduino Due
 # http://arduino.cc/en/Main/ArduinoBoardDue
 #
diff --git a/examples/targets/build_config_IntelEdison.rb b/target/IntelEdison.rb
index a22f9cfd2..a22f9cfd2 100644
--- a/examples/targets/build_config_IntelEdison.rb
+++ b/target/IntelEdison.rb
diff --git a/examples/targets/build_config_IntelGalileo.rb b/target/IntelGalileo.rb
index 42f39c456..e996efa5b 100644
--- a/examples/targets/build_config_IntelGalileo.rb
+++ b/target/IntelGalileo.rb
@@ -1,20 +1,3 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-end
-
-
 # Cross Compiling configuration for Intel Galileo on Arduino environment
 # http://arduino.cc/en/ArduinoCertified/IntelGalileo
 #
diff --git a/examples/targets/build_config_RX630.rb b/target/RX630.rb
index 8b1bbb42f..01c883958 100644
--- a/examples/targets/build_config_RX630.rb
+++ b/target/RX630.rb
@@ -1,19 +1,3 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-end
-
 # Cross Compiling configuration for RX630
 # http://gadget.renesas.com/
 #
@@ -30,7 +14,7 @@ MRuby::CrossBuild.new("RX630") do |conf|
     cc.compile_options = %Q[%{flags} -o "%{outfile}" -c "%{infile}"]
 
     #configuration for low memory environment
-    cc.defines << %w(MRB_USE_FLOAT)
+    cc.defines << %w(MRB_USE_FLOAT32)
     cc.defines << %w(MRB_HEAP_PAGE_SIZE=64)
     cc.defines << %w(KHASH_DEFAULT_SIZE=8)
     cc.defines << %w(MRB_STR_BUF_MIN_SIZE=20)
diff --git a/target/android_arm64-v8a.rb b/target/android_arm64-v8a.rb
new file mode 100644
index 000000000..7fab2f063
--- /dev/null
+++ b/target/android_arm64-v8a.rb
@@ -0,0 +1,11 @@
+# Requires Android NDK r13 or later.
+MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
+  params = {
+    :arch => 'arm64-v8a',
+    :platform => 'android-24',
+    :toolchain => :clang,
+  }
+  toolchain :android, params
+
+  conf.gembox 'default'
+end
diff --git a/target/android_armeabi.rb b/target/android_armeabi.rb
new file mode 100644
index 000000000..41a657c3b
--- /dev/null
+++ b/target/android_armeabi.rb
@@ -0,0 +1,11 @@
+# Requires Android NDK r13 or later.
+MRuby::CrossBuild.new('android-armeabi') do |conf|
+  params = {
+    :arch => 'armeabi',
+    :platform => 'android-24',
+    :toolchain => :clang,
+  }
+  toolchain :android, params
+
+  conf.gembox 'default'
+end
diff --git a/examples/targets/build_config_android_armeabi_v7a_neon_hard.rb b/target/android_armeabi_v7a_neon_hard.rb
index 3788bba7f..6129b238e 100644
--- a/examples/targets/build_config_android_armeabi_v7a_neon_hard.rb
+++ b/target/android_armeabi_v7a_neon_hard.rb
@@ -1,18 +1,3 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-end
-
 # Requires Android NDK r13 or later.
 MRuby::CrossBuild.new('android-armeabi-v7a-neon-hard') do |conf|
   params = {
diff --git a/target/appveyor.rb b/target/appveyor.rb
new file mode 100644
index 000000000..e084a6a36
--- /dev/null
+++ b/target/appveyor.rb
@@ -0,0 +1,18 @@
+def setup_option(conf)
+  conf.cc.flags[0].delete("/Zi") unless ENV['CFLAGS']
+  conf.cxx.flags[0].delete("/Zi") unless ENV['CFLAGS'] || ENV['CXXFLAGS']
+  conf.linker.flags << "/DEBUG:NONE" unless ENV['LDFLAGS']
+end
+
+MRuby::Build.new do |conf|
+  toolchain :visualcpp
+
+  # include all core GEMs
+  conf.gembox 'full-core'
+  conf.compilers.each do |c|
+    c.defines += %w(MRB_GC_FIXED_ARENA)
+  end
+  setup_option(conf)
+  conf.enable_bintest
+  conf.enable_test
+end
diff --git a/target/bench.rb b/target/bench.rb
new file mode 100644
index 000000000..30ec56ad3
--- /dev/null
+++ b/target/bench.rb
@@ -0,0 +1,11 @@
+MRuby::Build.new('bench') do |conf|
+  # Gets set by the VS command prompts.
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+    conf.cc.flags << '-O3'
+  end
+
+  conf.gembox 'default'
+end
diff --git a/benchmark/build_config_boxing.rb b/target/boxing.rb
index b478c9005..97c8e8ca9 100644
--- a/benchmark/build_config_boxing.rb
+++ b/target/boxing.rb
@@ -1,11 +1,11 @@
-MRuby::Build.new do |conf|
-  toolchain :gcc
-end
-
-MRuby::Build.new('no_boxing') do |conf|
+MRuby::Build.new('no-boxing') do |conf|
   toolchain :gcc
 
   conf.gembox 'default'
+  conf.compilers.each do |c|
+    c.defines += %w(MRB_NO_BOXING)
+  end
+  conf.enable_test
 end
 
 MRuby::Build.new('word_boxing') do |conf|
@@ -15,6 +15,7 @@ MRuby::Build.new('word_boxing') do |conf|
   conf.compilers.each do |c|
     c.defines += %w(MRB_WORD_BOXING)
   end
+  conf.enable_test
 end
 
 MRuby::Build.new('nan_boxing') do |conf|
@@ -24,5 +25,5 @@ MRuby::Build.new('nan_boxing') do |conf|
   conf.compilers.each do |c|
     c.defines += %w(MRB_NAN_BOXING)
   end
+  conf.enable_test
 end
-
diff --git a/examples/targets/build_config_chipKITMax32.rb b/target/chipKITMax32.rb
index 8617d8d10..bbee221f5 100644
--- a/examples/targets/build_config_chipKITMax32.rb
+++ b/target/chipKITMax32.rb
@@ -1,19 +1,3 @@
-MRuby::Build.new do |conf|
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-end
-
 # Cross Compiling configuration for Digilent chipKIT Max32
 # http://www.digilentinc.com/Products/Detail.cfm?Prod=CHIPKIT-MAX32
 #
diff --git a/target/clang-asan.rb b/target/clang-asan.rb
new file mode 100644
index 000000000..e693332c2
--- /dev/null
+++ b/target/clang-asan.rb
@@ -0,0 +1,21 @@
+MRuby::Build.new do |conf|
+  toolchain :clang
+  # include the GEM box
+  conf.gembox 'default'
+
+  # C compiler settings
+  conf.cc do |cc|
+    cc.flags << "-fsanitize=address,undefined"
+    cc.include_paths = ["#{root}/include"]
+  end
+
+  # Linker settings
+  conf.linker do |linker|
+    linker.flags << "-fsanitize=address,undefined"
+  end
+
+  # Turn on `enable_debug` for better debugging
+  enable_debug
+  conf.enable_bintest
+  conf.enable_test
+end
diff --git a/target/cross-32bit.rb b/target/cross-32bit.rb
new file mode 100644
index 000000000..82d5d023f
--- /dev/null
+++ b/target/cross-32bit.rb
@@ -0,0 +1,14 @@
+# Define cross build settings
+MRuby::CrossBuild.new('cross-32bit') do |conf|
+  toolchain :gcc
+
+  conf.cc.flags << "-m32"
+  conf.linker.flags << "-m32"
+
+  # conf.build_mrbtest_lib_only
+
+  conf.gem :core => "mruby-bin-mruby"
+  conf.gem "#{MRUBY_ROOT}/examples/mrbgems/c_and_ruby_extension_example"
+
+  conf.test_runner.command = 'env'
+end
diff --git a/examples/targets/build_config_dreamcast_shelf.rb b/target/dreamcast_shelf.rb
index 85b2ff20d..3ae53184d 100644
--- a/examples/targets/build_config_dreamcast_shelf.rb
+++ b/target/dreamcast_shelf.rb
@@ -1,17 +1,3 @@
-MRuby::Build.new do |conf|
-  # Gets set by the VS command prompts
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # Include the default GEMs
-  conf.gembox 'default'
-end
-
 # Cross Compiling configuration for the Sega Dreamcast
 # This configuration requires KallistiOS (KOS)
 # https://dreamcast.wiki
diff --git a/target/host-cxx.rb b/target/host-cxx.rb
new file mode 100644
index 000000000..ae05e63c2
--- /dev/null
+++ b/target/host-cxx.rb
@@ -0,0 +1,13 @@
+MRuby::Build.new do |conf|
+  toolchain :gcc
+
+  enable_debug
+  # include the default GEMs
+  conf.gembox 'full-core'
+
+  # C compiler settings
+  conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK)
+  conf.enable_debug
+  conf.enable_cxx_abi
+  conf.enable_test
+end
diff --git a/target/host-debug.rb b/target/host-debug.rb
new file mode 100644
index 000000000..ad4106065
--- /dev/null
+++ b/target/host-debug.rb
@@ -0,0 +1,26 @@
+MRuby::Build.new('host') do |conf|
+  # load specific toolchain settings
+
+  # Gets set by the VS command prompts.
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+  end
+
+  enable_debug
+
+  # include the default GEMs
+  conf.gembox 'full-core'
+
+  # C compiler settings
+  conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK MRB_NO_BOXING)
+
+  # Generate mruby debugger command (require mruby-eval)
+  conf.gem :core => "mruby-bin-debugger"
+
+  # test
+  enable_test
+  # bintest
+  enable_bintest
+end
diff --git a/target/host-gprof.rb b/target/host-gprof.rb
new file mode 100644
index 000000000..31b952920
--- /dev/null
+++ b/target/host-gprof.rb
@@ -0,0 +1,14 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox 'full-core'
+
+  conf.cc.flags << '-pg'
+  conf.linker.flags << '-pg'
+
+  # Turn on `enable_debug` for better debugging
+  enable_debug
+  conf.enable_test
+end
diff --git a/target/host-m32.rb b/target/host-m32.rb
new file mode 100644
index 000000000..39b2c952f
--- /dev/null
+++ b/target/host-m32.rb
@@ -0,0 +1,15 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+  toolchain :gcc
+
+  # include the GEM box
+  conf.gembox 'full-core'
+
+  conf.cc.flags << '-m32'
+  conf.linker.flags << '-m32'
+
+  # Turn on `enable_debug` for better debugging
+  enable_debug
+  conf.enable_test
+  conf.enable_bintest
+end
diff --git a/target/host-shared.rb b/target/host-shared.rb
new file mode 100644
index 000000000..8b5028837
--- /dev/null
+++ b/target/host-shared.rb
@@ -0,0 +1,36 @@
+MRuby::Build.new do |conf|
+  # load specific toolchain settings
+
+  # Gets set by the VS command prompts.
+  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+  end
+
+  # include the GEM box
+  conf.gembox 'default'
+
+  # C compiler settings
+  conf.cc do |cc|
+    cc.flags = '-fPIC'
+  end
+
+  conf.archiver do |archiver|
+    archiver.command = 'gcc'
+    archiver.archive_options = '-shared -o %{outfile} %{objs}'
+  end
+
+  # file extensions
+  conf.exts do |exts|
+     exts.library = '.so'
+  end
+
+  # file separetor
+  # conf.file_separator = '/'
+
+  # Turn on `enable_debug` for better debugging
+  enable_debug
+  conf.enable_bintest
+  conf.enable_test
+end
diff --git a/build_config.rb b/target/host.rb
index 254a28ce0..eb6e3c15f 100644
--- a/build_config.rb
+++ b/target/host.rb
@@ -8,9 +8,6 @@ MRuby::Build.new do |conf|
     toolchain :gcc
   end
 
-  # Turn on `enable_debug` for better debugging
-  # enable_debug
-
   # Use mrbgems
   # conf.gem 'examples/mrbgems/ruby_extension_example'
   # conf.gem 'examples/mrbgems/c_extension_example' do |g|
@@ -22,8 +19,9 @@ MRuby::Build.new do |conf|
   # conf.gem :github => 'mattn/mruby-onig-regexp'
   # conf.gem :git => '[email protected]:mattn/mruby-onig-regexp.git', :branch => 'master', :options => '-v'
 
-  # include the default GEMs
-  conf.gembox 'default'
+  # include the GEM box
+  conf.gembox 'full-core'
+
   # C compiler settings
   # conf.cc do |cc|
   #   cc.command = ENV['CC'] || 'gcc'
@@ -81,72 +79,8 @@ MRuby::Build.new do |conf|
   # file separetor
   # conf.file_separator = '/'
 
-  # bintest
-  # conf.enable_bintest
-end
-
-MRuby::Build.new('host-debug') do |conf|
-  # load specific toolchain settings
-
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
-  enable_debug
-
-  # include the default GEMs
-  conf.gembox 'default'
-
-  # C compiler settings
-  conf.cc.defines = %w(MRB_ENABLE_DEBUG_HOOK)
-
-  # Generate mruby debugger command (require mruby-eval)
-  conf.gem :core => "mruby-bin-debugger"
-
-  # bintest
-  # conf.enable_bintest
-end
-
-MRuby::Build.new('test') do |conf|
-  # Gets set by the VS command prompts.
-  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-    toolchain :visualcpp
-  else
-    toolchain :gcc
-  end
-
+  # Turn on `enable_debug` for better debugging
   enable_debug
   conf.enable_bintest
   conf.enable_test
-
-  conf.gembox 'default'
 end
-
-#MRuby::Build.new('bench') do |conf|
-#  # Gets set by the VS command prompts.
-#  if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']
-#    toolchain :visualcpp
-#  else
-#    toolchain :gcc
-#    conf.cc.flags << '-O3'
-#  end
-#
-#  conf.gembox 'default'
-#end
-
-# Define cross build settings
-# MRuby::CrossBuild.new('32bit') do |conf|
-#   toolchain :gcc
-#
-#   conf.cc.flags << "-m32"
-#   conf.linker.flags << "-m32"
-#
-#   conf.build_mrbtest_lib_only
-#
-#   conf.gem 'examples/mrbgems/c_and_ruby_extension_example'
-#
-#   conf.test_runner.command = 'env'
-# end
diff --git a/travis_config.rb b/target/travis.rb
index f4bef0a52..58a739ce6 100644
--- a/travis_config.rb
+++ b/target/travis.rb
@@ -5,7 +5,7 @@ MRuby::Build.new('full-debug') do |conf|
   # include all core GEMs
   conf.gembox 'full-core'
   conf.cc.flags += %w(-Werror=declaration-after-statement)
-  conf.cc.defines += %w(MRB_GC_STRESS MRB_METHOD_CACHE MRB_ENABLE_DEBUG_HOOK)
+  conf.cc.defines += %w(MRB_GC_STRESS MRB_ENABLE_DEBUG_HOOK)
 
   conf.enable_test
 end
@@ -31,7 +31,6 @@ MRuby::Build.new('cxx_abi') do |conf|
   conf.compilers.each do |c|
     c.defines += %w(MRB_GC_FIXED_ARENA)
   end
-  conf.enable_bintest
   conf.enable_test
 
   enable_cxx_abi
diff --git a/tasks/benchmark.rake b/tasks/benchmark.rake
index 6352f5c17..661fd2ada 100644
--- a/tasks/benchmark.rake
+++ b/tasks/benchmark.rake
@@ -9,11 +9,7 @@ def bm_files
 end
 
 def build_config_name
-  if ENV['MRUBY_CONFIG']
-    File.basename(ENV['MRUBY_CONFIG'], '.rb').gsub('build_config_', '')
-  else
-    "build"
-  end
+  MRUBY_TARGET
 end
 
 def plot_file
diff --git a/tasks/gitlab.rake b/tasks/gitlab.rake
index 377b1cc9d..5c7b3d8c5 100644
--- a/tasks/gitlab.rake
+++ b/tasks/gitlab.rake
@@ -62,10 +62,10 @@ task :gitlab_config do
 
   configs = []
   [true, false].each do |mode_32|
-    ['', 'MRB_USE_FLOAT'].each do |float_conf|
+    ['', 'MRB_USE_FLOAT32'].each do |float_conf|
       ['', 'MRB_NAN_BOXING', 'MRB_WORD_BOXING'].each do |boxing_conf|
         ['', 'MRB_UTF8_STRING'].each do |utf8_conf|
-          next if (float_conf == 'MRB_USE_FLOAT') && (boxing_conf == 'MRB_NAN_BOXING')
+          next if (float_conf == 'MRB_USE_FLOAT32') && (boxing_conf == 'MRB_NAN_BOXING')
           next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_NAN_BOXING')
           next if (int_conf == 'MRB_INT64') && (boxing_conf == 'MRB_WORD_BOXING') && mode_32
           env = [float_conf, int_conf, boxing_conf, utf8_conf].map do |conf|
diff --git a/tasks/libmruby.rake b/tasks/libmruby.rake
index 17f8534e2..e302ca02b 100644
--- a/tasks/libmruby.rake
+++ b/tasks/libmruby.rake
@@ -21,5 +21,4 @@ MRuby.each_target do
       f.puts "MRUBY_LIBMRUBY_PATH = #{libmruby_static}"
     end
   end
-  task :all => "#{build_dir}/lib/libmruby.flags.mak"
 end
diff --git a/test/t/array.rb b/test/t/array.rb
index eec31d751..2982cab01 100644
--- a/test/t/array.rb
+++ b/test/t/array.rb
@@ -372,8 +372,7 @@ end
 assert('Array#hash', '15.2.12.5.35') do
   a = [ 1, 2, 3 ]
 
-  #assert_true(a.hash.is_a? Integer)
-  assert_true(a.hash.is_a? Integral)  # mruby special
+  assert_true(a.hash.is_a? Integer)
   assert_equal([1,2].hash, [1,2].hash)
 end
 
diff --git a/test/t/bs_literal.rb b/test/t/bs_literal.rb
index c6c38140b..d60957f0b 100644
--- a/test/t/bs_literal.rb
+++ b/test/t/bs_literal.rb
@@ -34,5 +34,5 @@ assert('BS Literal 8') do
 end
 
 assert('BS Literal 9') do
-  assert_equal Fixnum, 1234.class
+  assert_equal Integer, 1234.class
 end
diff --git a/test/t/float.rb b/test/t/float.rb
index dc989636f..e2a8a5088 100644
--- a/test/t/float.rb
+++ b/test/t/float.rb
@@ -207,7 +207,7 @@ assert('Float#>>') do
 end
 
 assert('Float#to_s') do
-  uses_float = 4e38.infinite?  # enable MRB_USE_FLOAT?
+  uses_float = 4e38.infinite?  # enable MRB_USE_FLOAT32?
 
   assert_equal("Infinity", Float::INFINITY.to_s)
   assert_equal("-Infinity", (-Float::INFINITY).to_s)
@@ -239,6 +239,11 @@ assert('Float#to_s') do
   end
 end
 
+assert('Float#inspect') do
+  assert_equal("-3.25", -3.25.inspect)
+  assert_equal("50.0", 50.0.inspect)
+end
+
 assert('Float#eql?') do
   assert_operator(5.0, :eql?, 5.0)
   assert_not_operator(5.0, :eql?, 5)
diff --git a/test/t/integer.rb b/test/t/integer.rb
index f9c44a64f..5204eb91b 100644
--- a/test/t/integer.rb
+++ b/test/t/integer.rb
@@ -14,16 +14,6 @@ assert('Integer#+', '15.2.8.3.1') do
 
   assert_raise(TypeError){ 0+nil }
   assert_raise(TypeError){ 1+nil }
-
-  c = Mrbtest::FIXNUM_MAX + 1
-  d = Mrbtest::FIXNUM_MAX.__send__(:+, 1)
-
-  skip unless Object.const_defined?(:Float)
-  e = Mrbtest::FIXNUM_MAX + 1.0
-  assert_equal Float, c.class
-  assert_equal Float, d.class
-  assert_float e, c
-  assert_float e, d
 end
 
 assert('Integer#-', '15.2.8.3.2') do
@@ -32,37 +22,17 @@ assert('Integer#-', '15.2.8.3.2') do
 
   assert_equal 1, a
   assert_equal 1.0, b if Object.const_defined?(:Float)
-
-  c = Mrbtest::FIXNUM_MIN - 1
-  d = Mrbtest::FIXNUM_MIN.__send__(:-, 1)
-
-  skip unless Object.const_defined?(:Float)
-  e = Mrbtest::FIXNUM_MIN - 1.0
-  assert_equal Float, c.class
-  assert_equal Float, d.class
-  assert_float e, c
-  assert_float e, d
 end
 
 assert('Integer#*', '15.2.8.3.3') do
   a = 1*1
-  b = 1*1.0 if Object.const_defined?(:Float)
-
   assert_equal 1, a
-  assert_equal 1.0, b if Object.const_defined?(:Float)
-
+  if Object.const_defined?(:Float)
+    b = 1*1.0 
+    assert_equal 1.0, b
+  end
   assert_raise(TypeError){ 0*nil }
   assert_raise(TypeError){ 1*nil }
-
-  c = Mrbtest::FIXNUM_MAX * 2
-  d = Mrbtest::FIXNUM_MAX.__send__(:*, 2)
-
-  skip unless Object.const_defined?(:Float)
-  e = Mrbtest::FIXNUM_MAX * 2.0
-  assert_equal Float, c.class
-  assert_equal Float, d.class
-  assert_float e, c
-  assert_float e, d
 end
 
 assert('Integer#/', '15.2.8.3.4') do
@@ -156,7 +126,7 @@ assert('Integer#<<', '15.2.8.3.12') do
 
   skip unless Object.const_defined?(:Float)
 
-  # Overflow to Fixnum
+  # Overflow to Integer
   assert_float 9223372036854775808.0, 1 << 63
   assert_float(-13835058055282163712.0, -3 << 62)
 end
diff --git a/test/t/kernel.rb b/test/t/kernel.rb
index 606150147..cab1ddd3d 100644
--- a/test/t/kernel.rb
+++ b/test/t/kernel.rb
@@ -76,7 +76,7 @@ assert('Kernel.raise', '15.3.1.2.12') do
 end
 
 assert('Kernel#__id__', '15.3.1.3.3') do
-  assert_equal Fixnum, __id__.class
+  assert_equal Integer, __id__.class
 end
 
 assert('Kernel#__send__', '15.3.1.3.4') do
diff --git a/test/t/module.rb b/test/t/module.rb
index 12b7f1344..2957dec52 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -593,7 +593,7 @@ end
   #        to_f / other
   #      end
   #    end
-  #    Fixnum.send(:prepend, M)
+  #    Integer.send(:prepend, M)
   #    assert_equal(0.5, 1 / 2, "#{bug7983}")
   #  }
   #  assert_equal(0, 1 / 2)
diff --git a/test/t/numeric.rb b/test/t/numeric.rb
index af44a2e1a..8baf6c883 100644
--- a/test/t/numeric.rb
+++ b/test/t/numeric.rb
@@ -36,7 +36,7 @@ assert('Numeric#/', '15.2.8.3.4') do
   n = Class.new(Numeric){ def /(x); 15.1;end }.new
 
   assert_equal(2, 10/5)
-  assert_equal(0.0625, 1/16)
+  assert_equal(0, 1/16)
   assert_equal(15.1, n/10)
   assert_raise(TypeError){ 1/n }
   assert_raise(TypeError){ 1/nil }
diff --git a/test/t/superclass.rb b/test/t/superclass.rb
index 10b6438d3..f213b1247 100644
--- a/test/t/superclass.rb
+++ b/test/t/superclass.rb
@@ -25,20 +25,20 @@
   [:ArgumentError, :StandardError, '15.2.24.2'],
   # [:LocalJumpError, :StandardError, '15.2.25.2'],
   [:LocalJumpError, :ScriptError, '15.2.25.2'], # mruby specific
-  [:RangeError, :StandardError, '12.2.26.2'],
-  [:RegexpError, :StandardError, '12.2.27.2'],
-  [:RuntimeError, :StandardError, '12.2.28.2'],
-  [:TypeError, :StandardError, '12.2.29.2'],
-#  [:ZeroDivisionError, :StandardError, '12.2.30.2'],  # No ZeroDivisionError in mruby
+  [:RangeError, :StandardError, '15.2.26.2'],
+  [:RegexpError, :StandardError, '15.2.27.2'],
+  [:RuntimeError, :StandardError, '15.2.28.2'],
+  [:TypeError, :StandardError, '15.2.29.2'],
+  [:ZeroDivisionError, :StandardError, '15.2.30.2'],
   [:NameError, :StandardError, '15.2.31.2'],
   [:NoMethodError, :NameError, '15.2.32.2'],
   [:IndexError, :StandardError, '15.2.33.2'],
-#  [:IOError, :StandardError, '12.2.34.2'],
-#  [:EOFError, :IOError, '12.2.35.2'],
+#  [:IOError, :StandardError, '15.2.34.2'],
+#  [:EOFError, :IOError, '15.2.35.2'],
 #  [:SystemCallError, :StandardError, '15.2.36.2'],
-  [:ScriptError, :Exception, '12.2.37.2'],
-  [:SyntaxError, :ScriptError, '12.2.38.2'],
-#  [:LoadError, :ScriptError, '12.2.39,2'],
+  [:ScriptError, :Exception, '15.2.37.2'],
+  [:SyntaxError, :ScriptError, '15.2.38.2'],
+#  [:LoadError, :ScriptError, '15.2.39,2'],
 ].each do |cls, super_cls, iso|
   assert "Direct superclass of #{cls}", iso do
     skip "#{cls} isn't defined" unless Object.const_defined? cls
diff --git a/test/t/syntax.rb b/test/t/syntax.rb
index 436c06601..a52e0dcea 100644
--- a/test/t/syntax.rb
+++ b/test/t/syntax.rb
@@ -345,6 +345,15 @@ assert('splat object in assignment') do
   assert_equal [2], (a = *o)
 end
 
+assert('right-ward assignment') do
+  1 => a
+  assert_equal(1, a)
+  13.divmod(5) => a,b
+  assert_equal([2,3], [a, b])
+  13.divmod(5) => a,b => c, d
+  assert_equal([2,3,2,3], [a, b, c, d])
+end
+
 assert('splat object in case statement') do
   o = Object.new
   def o.to_a
diff --git a/test/t/vformat.rb b/test/t/vformat.rb
index df6950ee6..f645351ee 100644
--- a/test/t/vformat.rb
+++ b/test/t/vformat.rb
@@ -17,7 +17,7 @@ assert('mrb_vformat') do
   assert_equal '`t`: NilClass', vf.v('`t`: %t', nil)
   assert_equal '`t`: FalseClass', vf.v('`t`: %t', false)
   assert_equal '`t`: TrueClass', vf.v('`t`: %t', true)
-  assert_equal '`t`: Fixnum', vf.v('`t`: %t', 0)
+  assert_equal '`t`: Integer', vf.v('`t`: %t', 0)
   assert_equal '`t`: Hash', vf.v('`t`: %t', {k: "value"})
   assert_match '#<Class:#<Class:#<Hash:0x*>>>', vf.v('%t', sclass({}))
   assert_equal 'string and length', vf.l('string %l length', 'andante', 3)
@@ -29,13 +29,13 @@ assert('mrb_vformat') do
   assert_equal '`T`: NilClass', vf.v('`T`: %T', nil)
   assert_equal '`T`: FalseClass', vf.v('`T`: %T', false)
   assert_equal '`T`: TrueClass', vf.v('`T`: %T', true)
-  assert_equal '`T`: Fixnum', vf.v('`T`: %T', 0)
+  assert_equal '`T`: Integer', vf.v('`T`: %T', 0)
   assert_equal '`T`: Hash', vf.v('`T`: %T', {k: "value"})
   assert_match 'Class', vf.v('%T', sclass({}))
   assert_equal '`Y`: nil', vf.v('`Y`: %Y', nil)
   assert_equal '`Y`: false', vf.v('`Y`: %Y', false)
   assert_equal '`Y`: true', vf.v('`Y`: %Y', true)
-  assert_equal '`Y`: Fixnum', vf.v('`Y`: %Y', 0)
+  assert_equal '`Y`: Integer', vf.v('`Y`: %Y', 0)
   assert_equal '`Y`: Hash', vf.v('`Y`: %Y', {k: "value"})
   assert_equal 'Class', vf.v('%Y', sclass({}))
   assert_match '#<Class:#<String:0x*>>', vf.v('%v', sclass(""))