benchmark/*.yml: convert from benchmark/bm_*.rb

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@63900 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

254 files changed, 3595 insertions, 3200 deletions

diff --git a/benchmark/app_answer.yml b/benchmark/app_answer.yml
new file mode 100644
index 0000000000..ad6bf3be16
--- /dev/null
+++ b/benchmark/app_answer.yml
@@ -0,0 +1,18 @@
+benchmark:
+  app_answer: |
+    def ack(m, n)
+      if m == 0 then
+        n + 1
+      elsif n == 0 then
+        ack(m - 1, 1)
+      else
+        ack(m - 1, ack(m, n - 1))
+      end
+    end
+
+    def the_answer_to_life_the_universe_and_everything
+      (ack(3,7).to_s.split(//).inject(0){|s,x| s+x.to_i}.to_s + "2" ).to_i
+    end
+
+    answer = the_answer_to_life_the_universe_and_everything
+loop_count: 1
diff --git a/benchmark/app_aobench.yml b/benchmark/app_aobench.yml
new file mode 100644
index 0000000000..5479d0a421
--- /dev/null
+++ b/benchmark/app_aobench.yml
@@ -0,0 +1,295 @@
+prelude: |
+  # AO render benchmark
+  # Original program (C) Syoyo Fujita in Javascript (and other languages)
+  #      https://code.google.com/p/aobench/
+  # Ruby(yarv2llvm) version by Hideki Miura
+benchmark:
+  app_aobench: |
+    #
+
+    IMAGE_WIDTH = 256
+    IMAGE_HEIGHT = 256
+    NSUBSAMPLES = 2
+    NAO_SAMPLES = 8
+
+    class Vec
+      def initialize(x, y, z)
+        @x = x
+        @y = y
+        @z = z
+      end
+
+      attr_accessor :x, :y, :z
+
+      def vadd(b)
+        Vec.new(@x + b.x, @y + b.y, @z + b.z)
+      end
+
+      def vsub(b)
+        Vec.new(@x - b.x, @y - b.y, @z - b.z)
+      end
+
+      def vcross(b)
+        Vec.new(@y * b.z - @z * b.y,
+                @z * b.x - @x * b.z,
+                @x * b.y - @y * b.x)
+      end
+
+      def vdot(b)
+        @x * b.x + @y * b.y + @z * b.z
+      end
+
+      def vlength
+        Math.sqrt(@x * @x + @y * @y + @z * @z)
+      end
+
+      def vnormalize
+        len = vlength
+        v = Vec.new(@x, @y, @z)
+        if len > 1.0e-17 then
+          v.x = v.x / len
+          v.y = v.y / len
+          v.z = v.z / len
+        end
+        v
+      end
+    end
+
+
+    class Sphere
+      def initialize(center, radius)
+        @center = center
+        @radius = radius
+      end
+
+      attr_reader :center, :radius
+
+      def intersect(ray, isect)
+        rs = ray.org.vsub(@center)
+        b = rs.vdot(ray.dir)
+        c = rs.vdot(rs) - (@radius * @radius)
+        d = b * b - c
+        if d > 0.0 then
+          t = - b - Math.sqrt(d)
+
+          if t > 0.0 and t < isect.t then
+            isect.t = t
+            isect.hit = true
+            isect.pl = Vec.new(ray.org.x + ray.dir.x * t,
+                              ray.org.y + ray.dir.y * t,
+                              ray.org.z + ray.dir.z * t)
+            n = isect.pl.vsub(@center)
+            isect.n = n.vnormalize
+          else
+            0.0
+          end
+        end
+        nil
+      end
+    end
+
+    class Plane
+      def initialize(p, n)
+        @p = p
+        @n = n
+      end
+
+      def intersect(ray, isect)
+        d = -@p.vdot(@n)
+        v = ray.dir.vdot(@n)
+        v0 = v
+        if v < 0.0 then
+          v0 = -v
+        end
+        if v0 < 1.0e-17 then
+          return
+        end
+
+        t = -(ray.org.vdot(@n) + d) / v
+
+        if t > 0.0 and t < isect.t then
+          isect.hit = true
+          isect.t = t
+          isect.n = @n
+          isect.pl = Vec.new(ray.org.x + t * ray.dir.x,
+                            ray.org.y + t * ray.dir.y,
+                            ray.org.z + t * ray.dir.z)
+        end
+        nil
+      end
+    end
+
+    class Ray
+      def initialize(org, dir)
+        @org = org
+        @dir = dir
+      end
+
+      attr_accessor :org, :dir
+    end
+
+    class Isect
+      def initialize
+        @t = 10000000.0
+        @hit = false
+        @pl = Vec.new(0.0, 0.0, 0.0)
+        @n = Vec.new(0.0, 0.0, 0.0)
+      end
+
+      attr_accessor :t, :hit, :pl, :n
+    end
+
+    def clamp(f)
+      i = f * 255.5
+      if i > 255.0 then
+        i = 255.0
+      end
+      if i < 0.0 then
+        i = 0.0
+      end
+      i.to_i
+    end
+
+    def otherBasis(basis, n)
+      basis[2] = Vec.new(n.x, n.y, n.z)
+      basis[1] = Vec.new(0.0, 0.0, 0.0)
+
+      if n.x < 0.6 and n.x > -0.6 then
+        basis[1].x = 1.0
+      elsif n.y < 0.6 and n.y > -0.6 then
+        basis[1].y = 1.0
+      elsif n.z < 0.6 and n.z > -0.6 then
+        basis[1].z = 1.0
+      else
+        basis[1].x = 1.0
+      end
+
+      basis[0] = basis[1].vcross(basis[2])
+      basis[0] = basis[0].vnormalize
+
+      basis[1] = basis[2].vcross(basis[0])
+      basis[1] = basis[1].vnormalize
+    end
+
+    class Scene
+      def initialize
+        @spheres = Array.new
+        @spheres[0] = Sphere.new(Vec.new(-2.0, 0.0, -3.5), 0.5)
+        @spheres[1] = Sphere.new(Vec.new(-0.5, 0.0, -3.0), 0.5)
+        @spheres[2] = Sphere.new(Vec.new(1.0, 0.0, -2.2), 0.5)
+        @plane = Plane.new(Vec.new(0.0, -0.5, 0.0), Vec.new(0.0, 1.0, 0.0))
+      end
+
+      def ambient_occlusion(isect)
+        basis = Array.new
+        otherBasis(basis, isect.n)
+
+        ntheta    = NAO_SAMPLES
+        nphi      = NAO_SAMPLES
+        eps       = 0.0001
+        occlusion = 0.0
+
+        p0 = Vec.new(isect.pl.x + eps * isect.n.x,
+                    isect.pl.y + eps * isect.n.y,
+                    isect.pl.z + eps * isect.n.z)
+        nphi.times do |j|
+          ntheta.times do |i|
+            r = rand
+            phi = 2.0 * 3.14159265 * rand
+            x = Math.cos(phi) * Math.sqrt(1.0 - r)
+            y = Math.sin(phi) * Math.sqrt(1.0 - r)
+            z = Math.sqrt(r)
+
+            rx = x * basis[0].x + y * basis[1].x + z * basis[2].x
+            ry = x * basis[0].y + y * basis[1].y + z * basis[2].y
+            rz = x * basis[0].z + y * basis[1].z + z * basis[2].z
+
+            raydir = Vec.new(rx, ry, rz)
+            ray = Ray.new(p0, raydir)
+
+            occisect = Isect.new
+            @spheres[0].intersect(ray, occisect)
+            @spheres[1].intersect(ray, occisect)
+            @spheres[2].intersect(ray, occisect)
+            @plane.intersect(ray, occisect)
+            if occisect.hit then
+              occlusion = occlusion + 1.0
+            else
+              0.0
+            end
+          end
+        end
+
+        occlusion = (ntheta.to_f * nphi.to_f - occlusion) / (ntheta.to_f * nphi.to_f)
+
+        Vec.new(occlusion, occlusion, occlusion)
+      end
+
+      def render(w, h, nsubsamples)
+        cnt = 0
+        nsf = nsubsamples.to_f
+        h.times do |y|
+          w.times do |x|
+            rad = Vec.new(0.0, 0.0, 0.0)
+
+            # Subsampling
+            nsubsamples.times do |v|
+              nsubsamples.times do |u|
+
+                cnt = cnt + 1
+                wf = w.to_f
+                hf = h.to_f
+                xf = x.to_f
+                yf = y.to_f
+                uf = u.to_f
+                vf = v.to_f
+
+                px = (xf + (uf / nsf) - (wf / 2.0)) / (wf / 2.0)
+                py = -(yf + (vf / nsf) - (hf / 2.0)) / (hf / 2.0)
+
+                eye = Vec.new(px, py, -1.0).vnormalize
+
+                ray = Ray.new(Vec.new(0.0, 0.0, 0.0), eye)
+
+                isect = Isect.new
+                @spheres[0].intersect(ray, isect)
+                @spheres[1].intersect(ray, isect)
+                @spheres[2].intersect(ray, isect)
+                @plane.intersect(ray, isect)
+                if isect.hit then
+                  col = ambient_occlusion(isect)
+                  rad.x = rad.x + col.x
+                  rad.y = rad.y + col.y
+                  rad.z = rad.z + col.z
+                end
+              end
+            end
+
+            r = rad.x / (nsf * nsf)
+            g = rad.y / (nsf * nsf)
+            b = rad.z / (nsf * nsf)
+            printf("%c", clamp(r))
+            printf("%c", clamp(g))
+            printf("%c", clamp(b))
+          end
+          nil
+        end
+
+        nil
+      end
+    end
+
+    alias printf_orig printf
+    def printf *args
+    end
+
+    # File.open("ao.ppm", "w") do |fp|
+      printf("P6\n")
+      printf("%d %d\n", IMAGE_WIDTH, IMAGE_HEIGHT)
+      printf("255\n", IMAGE_WIDTH, IMAGE_HEIGHT)
+      Scene.new.render(IMAGE_WIDTH, IMAGE_HEIGHT, NSUBSAMPLES)
+    # end
+
+    undef printf
+    alias printf printf_orig
+loop_count: 1
diff --git a/benchmark/app_erb.yml b/benchmark/app_erb.yml
new file mode 100644
index 0000000000..df0630585f
--- /dev/null
+++ b/benchmark/app_erb.yml
@@ -0,0 +1,28 @@
+benchmark:
+  app_erb: |
+    #
+    # Create many HTML strings with ERB.
+    #
+
+    require 'erb'
+
+    data = <<erb
+    <html>
+      <head> <%= title %> </head>
+      <body>
+        <h1> <%= title %> </h1>
+        <p>
+          <%= content %>
+        </p>
+      </body>
+    </html>
+    erb
+
+    max = 15_000
+    title = "hello world!"
+    content = "hello world!\n" * 10
+
+    max.times{
+      ERB.new(data).result(binding)
+    }
+loop_count: 1
diff --git a/benchmark/app_factorial.yml b/benchmark/app_factorial.yml
new file mode 100644
index 0000000000..9db58e1a3c
--- /dev/null
+++ b/benchmark/app_factorial.yml
@@ -0,0 +1,14 @@
+benchmark:
+  app_factorial: |
+    def fact(n)
+      if(n > 1)
+        n * fact(n-1)
+      else
+        1
+      end
+    end
+
+    100.times {
+      fact(5000)
+    }
+loop_count: 1
diff --git a/benchmark/app_fib.yml b/benchmark/app_fib.yml
new file mode 100644
index 0000000000..d1c6671e9d
--- /dev/null
+++ b/benchmark/app_fib.yml
@@ -0,0 +1,12 @@
+benchmark:
+  app_fib: |
+    def fib n
+      if n < 3
+        1
+      else
+        fib(n-1) + fib(n-2)
+      end
+    end
+
+    fib(34)
+loop_count: 1
diff --git a/benchmark/app_lc_fizzbuzz.yml b/benchmark/app_lc_fizzbuzz.yml
new file mode 100644
index 0000000000..e17024c87b
--- /dev/null
+++ b/benchmark/app_lc_fizzbuzz.yml
@@ -0,0 +1,55 @@
+benchmark:
+  app_lc_fizzbuzz: |
+    #
+    # FizzBuzz program using only lambda calculus
+    #
+    # This program is quoted from
+    #   "Understanding Computation" by Tom Stuart
+    #   http://computationbook.com/
+    #
+    # You can understand why this program works fine by reading this book.
+    #
+
+    solution = -> k { -> f { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } }] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][y] }] } } } }][k][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { -> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[l][f[x]] } }] } }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[m][n]][-> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[f[-> n { -> p { -> x { p[n[p][x]] } } }[m]][n]][m][x] }][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]] } } }][-> p { -> x { p[x] } }][-> p { -> x { p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[x]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] } }]][-> n { -> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[x]]]]]]]]]]]]]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[x]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> n { -> l { -> x { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } }] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][y] }] } } } }][l][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][x]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }] } }[-> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> x { f[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { -> n { -> p { -> x { p[n[p][x]] } } }[f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n]][x] }][-> p { -> x { x } }] } } }][n][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][x] }]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]] } }][n]]]] }]
+
+    FIRST     = -> l { LEFT[RIGHT[l]] }
+    IF        = -> b { b }
+    LEFT      = -> p { p[-> x { -> y { x } } ] }
+    RIGHT     = -> p { p[-> x { -> y { y } } ] }
+    IS_EMPTY  = LEFT
+    REST      = -> l { RIGHT[RIGHT[l]] }
+
+    def to_integer(proc)
+      proc[-> n { n + 1 }][0]
+    end
+
+    def to_boolean(proc)
+      IF[proc][true][false]
+    end
+
+    def to_array(proc)
+      array = []
+
+      until to_boolean(IS_EMPTY[proc])
+        array.push(FIRST[proc])
+        proc = REST[proc]
+      end
+
+      array
+    end
+
+    def to_char(c)
+      '0123456789BFiuz'.slice(to_integer(c))
+    end
+
+    def to_string(s)
+      to_array(s).map { |c| to_char(c) }.join
+    end
+
+    answer = to_array(solution).map do |p|
+      to_string(p)
+    end
+
+    answer_ary = answer.to_a
+    # puts answer_ary
+loop_count: 1
diff --git a/benchmark/app_mandelbrot.yml b/benchmark/app_mandelbrot.yml
new file mode 100644
index 0000000000..d0ec9db010
--- /dev/null
+++ b/benchmark/app_mandelbrot.yml
@@ -0,0 +1,25 @@
+benchmark:
+  app_mandelbrot: |
+    require 'complex'
+
+    def mandelbrot? z
+      i = 0
+      while i<100
+        i += 1
+        z = z * z
+        return false if z.abs > 2
+      end
+      true
+    end
+
+    ary = []
+
+    (0..1000).each{|dx|
+      (0..1000).each{|dy|
+        x = dx / 50.0
+        y = dy / 50.0
+        c = Complex(x, y)
+        ary << c if mandelbrot?(c)
+      }
+    }
+loop_count: 1
diff --git a/benchmark/app_pentomino.yml b/benchmark/app_pentomino.yml
new file mode 100644
index 0000000000..6f152b1423
--- /dev/null
+++ b/benchmark/app_pentomino.yml
@@ -0,0 +1,262 @@
+prelude: |
+  #!/usr/local/bin/ruby
+  # This program is contributed by Shin Nishiyama
+benchmark:
+  app_pentomino: |
+
+
+    # modified by K.Sasada
+
+    NP = 5
+    ROW = 8 + NP
+    COL = 8
+
+    $p = []
+    $b = []
+    $no = 0
+
+    def piece(n, a, nb)
+      nb.each{|x|
+        a[n] = x
+        if n == NP-1
+          $p << [a.sort]
+        else
+          nbc=nb.dup
+          [-ROW, -1, 1, ROW].each{|d|
+            if x+d > 0 and not a.include?(x+d) and not nbc.include?(x+d)
+              nbc << x+d
+            end
+          }
+          nbc.delete x
+          piece(n+1,a[0..n],nbc)
+        end
+      }
+    end
+
+    def kikaku(a)
+      a.collect {|x| x - a[0]}
+    end
+    def ud(a)
+      kikaku(a.collect {|x| ((x+NP)%ROW)-ROW*((x+NP)/ROW) }.sort)
+    end
+    def rl(a)
+      kikaku(a.collect {|x| ROW*((x+NP)/ROW)+ROW-((x+NP)%ROW)}.sort)
+    end
+    def xy(a)
+      kikaku(a.collect {|x| ROW*((x+NP)%ROW) + (x+NP)/ROW }.sort)
+    end
+
+    def mkpieces
+      piece(0,[],[0])
+      $p.each do |a|
+        a0 = a[0]
+        a[1] = ud(a0)
+        a[2] = rl(a0)
+        a[3] = ud(rl(a0))
+        a[4] = xy(a0)
+        a[5] = ud(xy(a0))
+        a[6] = rl(xy(a0))
+        a[7] = ud(rl(xy(a0)))
+        a.sort!
+        a.uniq!
+      end
+      $p.uniq!.sort! {|x,y| x[0] <=> y[0] }
+    end
+
+    def mkboard
+      (0...ROW*COL).each{|i|
+        if i % ROW >= ROW-NP
+          $b[i] = -2
+        else
+          $b[i] = -1
+        end
+        $b[3*ROW+3]=$b[3*ROW+4]=$b[4*ROW+3]=$b[4*ROW+4]=-2
+      }
+    end
+
+    def pboard
+      return # skip print
+      print "No. #$no\n"
+      (0...COL).each{|i|
+        print "|"
+        (0...ROW-NP).each{|j|
+          x = $b[i*ROW+j]
+          if x < 0
+            print "..|"
+          else
+            printf "%2d|",x+1
+          end
+        }
+        print "\n"
+      }
+      print "\n"
+    end
+
+    $pnum=[]
+    def setpiece(a,pos)
+      if a.length == $p.length then
+        $no += 1
+        pboard
+        return
+      end
+      while $b[pos] != -1
+        pos += 1
+      end
+      ($pnum - a).each do |i|
+        $p[i].each do |x|
+          f = 0
+          x.each{|s|
+            if $b[pos+s] != -1
+              f=1
+              break
+            end
+          }
+          if f == 0 then
+            x.each{|s|
+              $b[pos+s] = i
+            }
+            a << i
+            setpiece(a.dup, pos)
+            a.pop
+            x.each{|s|
+              $b[pos+s] = -1
+            }
+          end
+        end
+      end
+    end
+
+    mkpieces
+    mkboard
+    $p[4] = [$p[4][0]]
+    $pnum = (0...$p.length).to_a
+    setpiece([],0)
+
+
+
+    # original
+
+    NP = 5
+    ROW = 8 + NP
+    COL = 8
+
+    $p = []
+    $b = []
+    $no = 0
+
+    def piece(n,a,nb)
+      for x in nb
+        a[n] = x
+        if n == NP-1
+          $p << [a.sort]
+        else
+          nbc=nb.dup
+          for d in [-ROW, -1, 1, ROW]
+            if x+d > 0 and not a.include?(x+d) and not nbc.include?(x+d)
+              nbc << x+d
+            end
+          end
+          nbc.delete x
+          piece(n+1,a[0..n],nbc)
+        end
+      end
+    end
+
+    def kikaku(a)
+      a.collect {|x| x - a[0]}
+    end
+    def ud(a)
+      kikaku(a.collect {|x| ((x+NP)%ROW)-ROW*((x+NP)/ROW) }.sort)
+    end
+    def rl(a)
+      kikaku(a.collect {|x| ROW*((x+NP)/ROW)+ROW-((x+NP)%ROW)}.sort)
+    end
+    def xy(a)
+      kikaku(a.collect {|x| ROW*((x+NP)%ROW) + (x+NP)/ROW }.sort)
+    end
+
+    def mkpieces
+      piece(0,[],[0])
+      $p.each do |a|
+        a0 = a[0]
+        a[1] = ud(a0)
+        a[2] = rl(a0)
+        a[3] = ud(rl(a0))
+        a[4] = xy(a0)
+        a[5] = ud(xy(a0))
+        a[6] = rl(xy(a0))
+        a[7] = ud(rl(xy(a0)))
+        a.sort!
+        a.uniq!
+      end
+      $p.uniq!.sort! {|x,y| x[0] <=> y[0] }
+    end
+
+    def mkboard
+      for i in 0...ROW*COL
+        if i % ROW >= ROW-NP
+          $b[i] = -2
+        else
+          $b[i] = -1
+        end
+        $b[3*ROW+3]=$b[3*ROW+4]=$b[4*ROW+3]=$b[4*ROW+4]=-2
+      end
+    end
+
+    def pboard
+      print "No. #$no\n"
+      for i in 0...COL
+        print "|"
+        for j in 0...ROW-NP
+          x = $b[i*ROW+j]
+          if x < 0
+            print "..|"
+          else
+            printf "%2d|",x+1
+          end
+        end
+        print "\n"
+      end
+      print "\n"
+    end
+
+    $pnum=[]
+    def setpiece(a,pos)
+      if a.length == $p.length then
+        $no += 1
+        pboard
+        return
+      end
+      while $b[pos] != -1
+        pos += 1
+      end
+      ($pnum - a).each do |i|
+        $p[i].each do |x|
+          f = 0
+          for s in x do
+            if $b[pos+s] != -1
+              f=1
+              break
+            end
+          end
+          if f == 0 then
+            for s in x do
+              $b[pos+s] = i
+            end
+            a << i
+            setpiece(a.dup, pos)
+            a.pop
+            for s in x do
+              $b[pos+s] = -1
+            end
+          end
+        end
+      end
+    end
+
+    mkpieces
+    mkboard
+    $p[4] = [$p[4][0]]
+    $pnum = (0...$p.length).to_a
+    setpiece([],0)
+loop_count: 1
diff --git a/benchmark/app_raise.yml b/benchmark/app_raise.yml
new file mode 100644
index 0000000000..3b7826c34f
--- /dev/null
+++ b/benchmark/app_raise.yml
@@ -0,0 +1,11 @@
+benchmark:
+  app_raise: |
+    i = 0
+    while i<300000
+      i += 1
+      begin
+        raise
+      rescue
+      end
+    end
+loop_count: 1
diff --git a/benchmark/app_strconcat.yml b/benchmark/app_strconcat.yml
new file mode 100644
index 0000000000..2762bf4aa2
--- /dev/null
+++ b/benchmark/app_strconcat.yml
@@ -0,0 +1,8 @@
+benchmark:
+  app_strconcat: |
+    i = 0
+    while i<2_000_000
+      "#{1+1} #{1+1} #{1+1}"
+      i += 1
+    end
+loop_count: 1
diff --git a/benchmark/app_tak.yml b/benchmark/app_tak.yml
new file mode 100644
index 0000000000..0b67558b32
--- /dev/null
+++ b/benchmark/app_tak.yml
@@ -0,0 +1,15 @@
+benchmark:
+  app_tak: |
+
+    def tak x, y, z
+      unless y < x
+        z
+      else
+        tak( tak(x-1, y, z),
+             tak(y-1, z, x),
+             tak(z-1, x, y))
+      end
+    end
+
+    tak(18, 9, 0)
+loop_count: 1
diff --git a/benchmark/app_tarai.yml b/benchmark/app_tarai.yml
new file mode 100644
index 0000000000..1f53db68a0
--- /dev/null
+++ b/benchmark/app_tarai.yml
@@ -0,0 +1,13 @@
+benchmark:
+  app_tarai: |
+    def tarai( x, y, z )
+      if x <= y
+      then y
+      else tarai(tarai(x-1, y, z),
+                 tarai(y-1, z, x),
+                 tarai(z-1, x, y))
+      end
+    end
+
+    tarai(12, 6, 0)
+loop_count: 1
diff --git a/benchmark/app_uri.yml b/benchmark/app_uri.yml
new file mode 100644
index 0000000000..1f7e49de51
--- /dev/null
+++ b/benchmark/app_uri.yml
@@ -0,0 +1,11 @@
+benchmark:
+  app_uri: |
+    require 'uri'
+
+    100_000.times{
+      uri = URI.parse('http://www.ruby-lang.org')
+      uri.scheme
+      uri.host
+      uri.port
+    }
+loop_count: 1
diff --git a/benchmark/array_sample_100k_10.yml b/benchmark/array_sample_100k_10.yml
new file mode 100644
index 0000000000..043e2fdf1c
--- /dev/null
+++ b/benchmark/array_sample_100k_10.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sample_100k_10: |
+    arr = [*0...100000]
+    10_000.times {arr.sample 10}
+loop_count: 1
diff --git a/benchmark/array_sample_100k_11.yml b/benchmark/array_sample_100k_11.yml
new file mode 100644
index 0000000000..0072c46930
--- /dev/null
+++ b/benchmark/array_sample_100k_11.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sample_100k_11: |
+    arr = [*0...100000]
+    10_000.times {arr.sample 11}
+loop_count: 1
diff --git a/benchmark/array_sample_100k__100.yml b/benchmark/array_sample_100k__100.yml
new file mode 100644
index 0000000000..93d25b3053
--- /dev/null
+++ b/benchmark/array_sample_100k__100.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sample_100k__100: |
+    arr = [*0...100000]
+    10_000.times {arr.sample 100}
+loop_count: 1
diff --git a/benchmark/array_sample_100k__1k.yml b/benchmark/array_sample_100k__1k.yml
new file mode 100644
index 0000000000..a6a66ef5dc
--- /dev/null
+++ b/benchmark/array_sample_100k__1k.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sample_100k__1k: |
+    arr = [*0...100000]
+    10_000.times {arr.sample 1000}
+loop_count: 1
diff --git a/benchmark/array_sample_100k__6k.yml b/benchmark/array_sample_100k__6k.yml
new file mode 100644
index 0000000000..438a345b8f
--- /dev/null
+++ b/benchmark/array_sample_100k__6k.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sample_100k__6k: |
+    arr = [*0...100000]
+    10_000.times {arr.sample 6000}
+loop_count: 1
diff --git a/benchmark/array_sample_100k___10k.yml b/benchmark/array_sample_100k___10k.yml
new file mode 100644
index 0000000000..13da9ccd83
--- /dev/null
+++ b/benchmark/array_sample_100k___10k.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sample_100k___10k: |
+    arr = [*0...100000]
+    10_000.times {arr.sample 10_000}
+loop_count: 1
diff --git a/benchmark/array_sample_100k___50k.yml b/benchmark/array_sample_100k___50k.yml
new file mode 100644
index 0000000000..579312dc3f
--- /dev/null
+++ b/benchmark/array_sample_100k___50k.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sample_100k___50k: |
+    arr = [*0...100000]
+    10_000.times {arr.sample 50_000}
+loop_count: 1
diff --git a/benchmark/array_shift.yml b/benchmark/array_shift.yml
new file mode 100644
index 0000000000..713c542024
--- /dev/null
+++ b/benchmark/array_shift.yml
@@ -0,0 +1,17 @@
+benchmark:
+  array_shift: |
+    require 'benchmark'
+
+    Benchmark.bm do |x|
+      [10_000,1_000_000,100_000_000].each do |n|
+        ary = Array.new(n,0)
+        GC.start
+        x.report("#{n}:shift"){ ary.shift }
+        (0..4).each do |i|
+          ary = Array.new(n,0)
+          GC.start
+          x.report("#{n}:shift(#{i})"){ ary.shift(i) }
+        end
+      end
+    end
+loop_count: 1
diff --git a/benchmark/array_small_and.yml b/benchmark/array_small_and.yml
new file mode 100644
index 0000000000..34d2e8ff58
--- /dev/null
+++ b/benchmark/array_small_and.yml
@@ -0,0 +1,20 @@
+benchmark:
+  array_small_and: |
+    MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
+    MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
+    ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
+
+    ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
+      (MIN_SIZE..MAX_SIZE).map do |size2|
+        [Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
+      end
+    end
+
+    ITERATIONS.times do
+      ARRAYS.each do |group|
+        group.each do |arr1, arr2|
+          arr1 & arr2
+        end
+      end
+    end
+loop_count: 1
diff --git a/benchmark/array_small_diff.yml b/benchmark/array_small_diff.yml
new file mode 100644
index 0000000000..64710e96bf
--- /dev/null
+++ b/benchmark/array_small_diff.yml
@@ -0,0 +1,20 @@
+benchmark:
+  array_small_diff: |
+    MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
+    MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
+    ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
+
+    ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
+      (MIN_SIZE..MAX_SIZE).map do |size2|
+        [Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
+      end
+    end
+
+    ITERATIONS.times do
+      ARRAYS.each do |group|
+        group.each do |arr1, arr2|
+          arr1 - arr2
+        end
+      end
+    end
+loop_count: 1
diff --git a/benchmark/array_small_or.yml b/benchmark/array_small_or.yml
new file mode 100644
index 0000000000..9338bd5dbd
--- /dev/null
+++ b/benchmark/array_small_or.yml
@@ -0,0 +1,20 @@
+benchmark:
+  array_small_or: |
+    MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
+    MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
+    ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
+
+    ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
+      (MIN_SIZE..MAX_SIZE).map do |size2|
+        [Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
+      end
+    end
+
+    ITERATIONS.times do
+      ARRAYS.each do |group|
+        group.each do |arr1, arr2|
+          arr1 | arr2
+        end
+      end
+    end
+loop_count: 1
diff --git a/benchmark/array_sort_block.yml b/benchmark/array_sort_block.yml
new file mode 100644
index 0000000000..775db90f4b
--- /dev/null
+++ b/benchmark/array_sort_block.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sort_block: |
+    ary = Array.new(1000) { rand(1000) }
+    10000.times { ary.sort { |a, b| a <=> b } }
+loop_count: 1
diff --git a/benchmark/array_sort_float.yml b/benchmark/array_sort_float.yml
new file mode 100644
index 0000000000..2aa2bd5fec
--- /dev/null
+++ b/benchmark/array_sort_float.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_sort_float: |
+    arr = Array.new(1000) { rand }
+    10000.times { arr.sort }
+loop_count: 1
diff --git a/benchmark/array_values_at_int.yml b/benchmark/array_values_at_int.yml
new file mode 100644
index 0000000000..48bb0f7492
--- /dev/null
+++ b/benchmark/array_values_at_int.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_values_at_int: |
+    ary = Array.new(10000) {|i| i}
+    100000.times { ary.values_at(500) }
+loop_count: 1
diff --git a/benchmark/array_values_at_range.yml b/benchmark/array_values_at_range.yml
new file mode 100644
index 0000000000..9de66261bb
--- /dev/null
+++ b/benchmark/array_values_at_range.yml
@@ -0,0 +1,5 @@
+benchmark:
+  array_values_at_range: |
+    ary = Array.new(10000) {|i| i}
+    100000.times { ary.values_at(1..2000) }
+loop_count: 1
diff --git a/benchmark/bighash.yml b/benchmark/bighash.yml
new file mode 100644
index 0000000000..65d74049e7
--- /dev/null
+++ b/benchmark/bighash.yml
@@ -0,0 +1,4 @@
+benchmark:
+  bighash: |
+    h = {}; 5000000.times {|n| h[n] = n }
+loop_count: 1
diff --git a/benchmark/bm_app_answer.rb b/benchmark/bm_app_answer.rb
deleted file mode 100644
index 3cd8a8fd37..0000000000
--- a/benchmark/bm_app_answer.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-def ack(m, n)
-  if m == 0 then
-    n + 1
-  elsif n == 0 then
-    ack(m - 1, 1)
-  else
-    ack(m - 1, ack(m, n - 1))
-  end
-end
-
-def the_answer_to_life_the_universe_and_everything
-  (ack(3,7).to_s.split(//).inject(0){|s,x| s+x.to_i}.to_s + "2" ).to_i
-end
-
-answer = the_answer_to_life_the_universe_and_everything
diff --git a/benchmark/bm_app_aobench.rb b/benchmark/bm_app_aobench.rb
deleted file mode 100644
index 2bd6acfaf8..0000000000
--- a/benchmark/bm_app_aobench.rb
+++ /dev/null
@@ -1,291 +0,0 @@
-# AO render benchmark
-# Original program (C) Syoyo Fujita in Javascript (and other languages)
-#      https://code.google.com/p/aobench/
-# Ruby(yarv2llvm) version by Hideki Miura
-#
-
-IMAGE_WIDTH = 256
-IMAGE_HEIGHT = 256
-NSUBSAMPLES = 2
-NAO_SAMPLES = 8
-
-class Vec
-  def initialize(x, y, z)
-    @x = x
-    @y = y
-    @z = z
-  end
-
-  attr_accessor :x, :y, :z
-
-  def vadd(b)
-    Vec.new(@x + b.x, @y + b.y, @z + b.z)
-  end
-
-  def vsub(b)
-    Vec.new(@x - b.x, @y - b.y, @z - b.z)
-  end
-
-  def vcross(b)
-    Vec.new(@y * b.z - @z * b.y,
-            @z * b.x - @x * b.z,
-            @x * b.y - @y * b.x)
-  end
-
-  def vdot(b)
-    @x * b.x + @y * b.y + @z * b.z
-  end
-
-  def vlength
-    Math.sqrt(@x * @x + @y * @y + @z * @z)
-  end
-
-  def vnormalize
-    len = vlength
-    v = Vec.new(@x, @y, @z)
-    if len > 1.0e-17 then
-      v.x = v.x / len
-      v.y = v.y / len
-      v.z = v.z / len
-    end
-    v
-  end
-end
-
-
-class Sphere
-  def initialize(center, radius)
-    @center = center
-    @radius = radius
-  end
-
-  attr_reader :center, :radius
-
-  def intersect(ray, isect)
-    rs = ray.org.vsub(@center)
-    b = rs.vdot(ray.dir)
-    c = rs.vdot(rs) - (@radius * @radius)
-    d = b * b - c
-    if d > 0.0 then
-      t = - b - Math.sqrt(d)
-
-      if t > 0.0 and t < isect.t then
-        isect.t = t
-        isect.hit = true
-        isect.pl = Vec.new(ray.org.x + ray.dir.x * t,
-                          ray.org.y + ray.dir.y * t,
-                          ray.org.z + ray.dir.z * t)
-        n = isect.pl.vsub(@center)
-        isect.n = n.vnormalize
-      else
-        0.0
-      end
-    end
-    nil
-  end
-end
-
-class Plane
-  def initialize(p, n)
-    @p = p
-    @n = n
-  end
-
-  def intersect(ray, isect)
-    d = -@p.vdot(@n)
-    v = ray.dir.vdot(@n)
-    v0 = v
-    if v < 0.0 then
-      v0 = -v
-    end
-    if v0 < 1.0e-17 then
-      return
-    end
-
-    t = -(ray.org.vdot(@n) + d) / v
-
-    if t > 0.0 and t < isect.t then
-      isect.hit = true
-      isect.t = t
-      isect.n = @n
-      isect.pl = Vec.new(ray.org.x + t * ray.dir.x,
-                        ray.org.y + t * ray.dir.y,
-                        ray.org.z + t * ray.dir.z)
-    end
-    nil
-  end
-end
-
-class Ray
-  def initialize(org, dir)
-    @org = org
-    @dir = dir
-  end
-
-  attr_accessor :org, :dir
-end
-
-class Isect
-  def initialize
-    @t = 10000000.0
-    @hit = false
-    @pl = Vec.new(0.0, 0.0, 0.0)
-    @n = Vec.new(0.0, 0.0, 0.0)
-  end
-
-  attr_accessor :t, :hit, :pl, :n
-end
-
-def clamp(f)
-  i = f * 255.5
-  if i > 255.0 then
-    i = 255.0
-  end
-  if i < 0.0 then
-    i = 0.0
-  end
-  i.to_i
-end
-
-def otherBasis(basis, n)
-  basis[2] = Vec.new(n.x, n.y, n.z)
-  basis[1] = Vec.new(0.0, 0.0, 0.0)
-
-  if n.x < 0.6 and n.x > -0.6 then
-    basis[1].x = 1.0
-  elsif n.y < 0.6 and n.y > -0.6 then
-    basis[1].y = 1.0
-  elsif n.z < 0.6 and n.z > -0.6 then
-    basis[1].z = 1.0
-  else
-    basis[1].x = 1.0
-  end
-
-  basis[0] = basis[1].vcross(basis[2])
-  basis[0] = basis[0].vnormalize
-
-  basis[1] = basis[2].vcross(basis[0])
-  basis[1] = basis[1].vnormalize
-end
-
-class Scene
-  def initialize
-    @spheres = Array.new
-    @spheres[0] = Sphere.new(Vec.new(-2.0, 0.0, -3.5), 0.5)
-    @spheres[1] = Sphere.new(Vec.new(-0.5, 0.0, -3.0), 0.5)
-    @spheres[2] = Sphere.new(Vec.new(1.0, 0.0, -2.2), 0.5)
-    @plane = Plane.new(Vec.new(0.0, -0.5, 0.0), Vec.new(0.0, 1.0, 0.0))
-  end
-
-  def ambient_occlusion(isect)
-    basis = Array.new
-    otherBasis(basis, isect.n)
-
-    ntheta    = NAO_SAMPLES
-    nphi      = NAO_SAMPLES
-    eps       = 0.0001
-    occlusion = 0.0
-
-    p0 = Vec.new(isect.pl.x + eps * isect.n.x,
-                isect.pl.y + eps * isect.n.y,
-                isect.pl.z + eps * isect.n.z)
-    nphi.times do |j|
-      ntheta.times do |i|
-        r = rand
-        phi = 2.0 * 3.14159265 * rand
-        x = Math.cos(phi) * Math.sqrt(1.0 - r)
-        y = Math.sin(phi) * Math.sqrt(1.0 - r)
-        z = Math.sqrt(r)
-
-        rx = x * basis[0].x + y * basis[1].x + z * basis[2].x
-        ry = x * basis[0].y + y * basis[1].y + z * basis[2].y
-        rz = x * basis[0].z + y * basis[1].z + z * basis[2].z
-
-        raydir = Vec.new(rx, ry, rz)
-        ray = Ray.new(p0, raydir)
-
-        occisect = Isect.new
-        @spheres[0].intersect(ray, occisect)
-        @spheres[1].intersect(ray, occisect)
-        @spheres[2].intersect(ray, occisect)
-        @plane.intersect(ray, occisect)
-        if occisect.hit then
-          occlusion = occlusion + 1.0
-        else
-          0.0
-        end
-      end
-    end
-
-    occlusion = (ntheta.to_f * nphi.to_f - occlusion) / (ntheta.to_f * nphi.to_f)
-
-    Vec.new(occlusion, occlusion, occlusion)
-  end
-
-  def render(w, h, nsubsamples)
-    cnt = 0
-    nsf = nsubsamples.to_f
-    h.times do |y|
-      w.times do |x|
-        rad = Vec.new(0.0, 0.0, 0.0)
-
-        # Subsampling
-        nsubsamples.times do |v|
-          nsubsamples.times do |u|
-
-            cnt = cnt + 1
-            wf = w.to_f
-            hf = h.to_f
-            xf = x.to_f
-            yf = y.to_f
-            uf = u.to_f
-            vf = v.to_f
-
-            px = (xf + (uf / nsf) - (wf / 2.0)) / (wf / 2.0)
-            py = -(yf + (vf / nsf) - (hf / 2.0)) / (hf / 2.0)
-
-            eye = Vec.new(px, py, -1.0).vnormalize
-
-            ray = Ray.new(Vec.new(0.0, 0.0, 0.0), eye)
-
-            isect = Isect.new
-            @spheres[0].intersect(ray, isect)
-            @spheres[1].intersect(ray, isect)
-            @spheres[2].intersect(ray, isect)
-            @plane.intersect(ray, isect)
-            if isect.hit then
-              col = ambient_occlusion(isect)
-              rad.x = rad.x + col.x
-              rad.y = rad.y + col.y
-              rad.z = rad.z + col.z
-            end
-          end
-        end
-
-        r = rad.x / (nsf * nsf)
-        g = rad.y / (nsf * nsf)
-        b = rad.z / (nsf * nsf)
-        printf("%c", clamp(r))
-        printf("%c", clamp(g))
-        printf("%c", clamp(b))
-      end
-      nil
-    end
-
-    nil
-  end
-end
-
-alias printf_orig printf
-def printf *args
-end
-
-# File.open("ao.ppm", "w") do |fp|
-  printf("P6\n")
-  printf("%d %d\n", IMAGE_WIDTH, IMAGE_HEIGHT)
-  printf("255\n", IMAGE_WIDTH, IMAGE_HEIGHT)
-  Scene.new.render(IMAGE_WIDTH, IMAGE_HEIGHT, NSUBSAMPLES)
-# end
-
-undef printf
-alias printf printf_orig
diff --git a/benchmark/bm_app_erb.rb b/benchmark/bm_app_erb.rb
deleted file mode 100644
index 9a1cb2707f..0000000000
--- a/benchmark/bm_app_erb.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-#
-# Create many HTML strings with ERB.
-#
-
-require 'erb'
-
-data = <<erb
-<html>
-  <head> <%= title %> </head>
-  <body>
-    <h1> <%= title %> </h1>
-    <p>
-      <%= content %>
-    </p>
-  </body>
-</html>
-erb
-
-max = 15_000
-title = "hello world!"
-content = "hello world!\n" * 10
-
-max.times{
-  ERB.new(data).result(binding)
-}
diff --git a/benchmark/bm_app_factorial.rb b/benchmark/bm_app_factorial.rb
deleted file mode 100644
index 45f471dfdb..0000000000
--- a/benchmark/bm_app_factorial.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-def fact(n)
-  if(n > 1)
-    n * fact(n-1)
-  else
-    1
-  end
-end
-
-100.times {
-  fact(5000)
-}
diff --git a/benchmark/bm_app_fib.rb b/benchmark/bm_app_fib.rb
deleted file mode 100644
index 34a7b2e725..0000000000
--- a/benchmark/bm_app_fib.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-def fib n
-  if n < 3
-    1
-  else
-    fib(n-1) + fib(n-2)
-  end
-end
-
-fib(34)
-
diff --git a/benchmark/bm_app_lc_fizzbuzz.rb b/benchmark/bm_app_lc_fizzbuzz.rb
deleted file mode 100644
index f09574bbeb..0000000000
--- a/benchmark/bm_app_lc_fizzbuzz.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-#
-# FizzBuzz program using only lambda calculus
-#
-# This program is quoted from
-#   "Understanding Computation" by Tom Stuart
-#   http://computationbook.com/
-#
-# You can understand why this program works fine by reading this book.
-#
-
-solution = -> k { -> f { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } }] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][y] }] } } } }][k][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> l { -> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[l][f[x]] } }] } }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[m][n]][-> x { -> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[f[-> n { -> p { -> x { p[n[p][x]] } } }[m]][n]][m][x] }][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]] } } }][-> p { -> x { p[x] } }][-> p { -> x { p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[x]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] } }]][-> n { -> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[p[p[p[p[p[p[p[p[p[p[p[p[x]]]]]]]]]]]]]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[x]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> b { b }[-> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]]][-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> n { -> p { -> x { p[n[p][x]] } } }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]]]][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> n { -> l { -> x { -> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> l { -> x { -> g { -> b { b }[-> p { p[-> x { -> y { x } }] }[l]][x][-> y { g[f[-> l { -> p { p[-> x { -> y { y } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][x][g]][-> l { -> p { p[-> x { -> y { x } }] }[-> p { p[-> x { -> y { y } }] }[l]] }[l]][y] }] } } } }][l][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }[-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][x]][-> l { -> x { -> x { -> y { -> f { f[x][y] } } }[-> x { -> y { y } }][-> x { -> y { -> f { f[x][y] } } }[x][l]] } }] } }[-> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }[-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]]][-> x { -> y { -> f { f[x][y] } } }[-> x { -> y { x } }][-> x { -> y { x } }]][-> x { f[-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { -> n { -> p { -> x { p[n[p][x]] } } }[f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n]][x] }][-> p { -> x { x } }] } } }][n][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]][x] }]][-> f { -> x { f[-> y { x[x][y] }] }[-> x { f[-> y { x[x][y] }] }] }[-> f { -> m { -> n { -> b { b }[-> m { -> n { -> n { n[-> x { -> x { -> y { y } } }][-> x { -> y { x } }] }[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]] } }[n][m]][-> x { f[-> m { -> n { n[-> n { -> p { p[-> x { -> y { x } }] }[n[-> p { -> x { -> y { -> f { f[x][y] } } }[-> p { p[-> x { -> y { y } }] }[p]][-> n { -> p { -> x { p[n[p][x]] } } }[-> p { p[-> x { -> y { y } }] }[p]]] }][-> x { -> y { -> f { f[x][y] } } }[-> p { -> x { x } }][-> p { -> x { x } }]]] }][m] } }[m][n]][n][x] }][m] } } }][n][-> m { -> n { n[-> m { -> n { n[-> n { -> p { -> x { p[n[p][x]] } } }][m] } }[m]][-> p { -> x { x } }] } }[-> p { -> x { p[p[x]] } }][-> p { -> x { p[p[p[p[p[x]]]]] } }]]] } }][n]]]] }]
-
-FIRST     = -> l { LEFT[RIGHT[l]] }
-IF        = -> b { b }
-LEFT      = -> p { p[-> x { -> y { x } } ] }
-RIGHT     = -> p { p[-> x { -> y { y } } ] }
-IS_EMPTY  = LEFT
-REST      = -> l { RIGHT[RIGHT[l]] }
-
-def to_integer(proc)
-  proc[-> n { n + 1 }][0]
-end
-
-def to_boolean(proc)
-  IF[proc][true][false]
-end
-
-def to_array(proc)
-  array = []
-
-  until to_boolean(IS_EMPTY[proc])
-    array.push(FIRST[proc])
-    proc = REST[proc]
-  end
-
-  array
-end
-
-def to_char(c)
-  '0123456789BFiuz'.slice(to_integer(c))
-end
-
-def to_string(s)
-  to_array(s).map { |c| to_char(c) }.join
-end
-
-answer = to_array(solution).map do |p|
-  to_string(p)
-end
-
-answer_ary = answer.to_a
-# puts answer_ary
diff --git a/benchmark/bm_app_mandelbrot.rb b/benchmark/bm_app_mandelbrot.rb
deleted file mode 100644
index 801b75e8e2..0000000000
--- a/benchmark/bm_app_mandelbrot.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-require 'complex'
-
-def mandelbrot? z
-  i = 0
-  while i<100
-    i += 1
-    z = z * z
-    return false if z.abs > 2
-  end
-  true
-end
-
-ary = []
-
-(0..1000).each{|dx|
-  (0..1000).each{|dy|
-    x = dx / 50.0
-    y = dy / 50.0
-    c = Complex(x, y)
-    ary << c if mandelbrot?(c)
-  }
-}
-
diff --git a/benchmark/bm_app_pentomino.rb b/benchmark/bm_app_pentomino.rb
deleted file mode 100644
index 59c63f358e..0000000000
--- a/benchmark/bm_app_pentomino.rb
+++ /dev/null
@@ -1,259 +0,0 @@
-#!/usr/local/bin/ruby
-# This program is contributed by Shin Nishiyama
-
-
-# modified by K.Sasada
-
-NP = 5
-ROW = 8 + NP
-COL = 8
-
-$p = []
-$b = []
-$no = 0
-
-def piece(n, a, nb)
-  nb.each{|x|
-    a[n] = x
-    if n == NP-1
-      $p << [a.sort]
-    else
-      nbc=nb.dup
-      [-ROW, -1, 1, ROW].each{|d|
-        if x+d > 0 and not a.include?(x+d) and not nbc.include?(x+d)
-          nbc << x+d
-        end
-      }
-      nbc.delete x
-      piece(n+1,a[0..n],nbc)
-    end
-  }
-end
-
-def kikaku(a)
-  a.collect {|x| x - a[0]}
-end
-def ud(a)
-  kikaku(a.collect {|x| ((x+NP)%ROW)-ROW*((x+NP)/ROW) }.sort)
-end
-def rl(a)
-  kikaku(a.collect {|x| ROW*((x+NP)/ROW)+ROW-((x+NP)%ROW)}.sort)
-end
-def xy(a)
-  kikaku(a.collect {|x| ROW*((x+NP)%ROW) + (x+NP)/ROW }.sort)
-end
-
-def mkpieces
-  piece(0,[],[0])
-  $p.each do |a|
-    a0 = a[0]
-    a[1] = ud(a0)
-    a[2] = rl(a0)
-    a[3] = ud(rl(a0))
-    a[4] = xy(a0)
-    a[5] = ud(xy(a0))
-    a[6] = rl(xy(a0))
-    a[7] = ud(rl(xy(a0)))
-    a.sort!
-    a.uniq!
-  end
-  $p.uniq!.sort! {|x,y| x[0] <=> y[0] }
-end
-
-def mkboard
-  (0...ROW*COL).each{|i|
-    if i % ROW >= ROW-NP
-      $b[i] = -2
-    else
-      $b[i] = -1
-    end
-    $b[3*ROW+3]=$b[3*ROW+4]=$b[4*ROW+3]=$b[4*ROW+4]=-2
-  }
-end
-
-def pboard
-  return # skip print
-  print "No. #$no\n"
-  (0...COL).each{|i|
-    print "|"
-    (0...ROW-NP).each{|j|
-      x = $b[i*ROW+j]
-      if x < 0
-        print "..|"
-      else
-        printf "%2d|",x+1
-      end
-    }
-    print "\n"
-  }
-  print "\n"
-end
-
-$pnum=[]
-def setpiece(a,pos)
-  if a.length == $p.length then
-    $no += 1
-    pboard
-    return
-  end
-  while $b[pos] != -1
-    pos += 1
-  end
-  ($pnum - a).each do |i|
-    $p[i].each do |x|
-      f = 0
-      x.each{|s|
-        if $b[pos+s] != -1
-          f=1
-          break
-        end
-      }
-      if f == 0 then
-        x.each{|s|
-          $b[pos+s] = i
-        }
-        a << i
-        setpiece(a.dup, pos)
-        a.pop
-        x.each{|s|
-          $b[pos+s] = -1
-        }
-      end
-    end
-  end
-end
-
-mkpieces
-mkboard
-$p[4] = [$p[4][0]]
-$pnum = (0...$p.length).to_a
-setpiece([],0)
-
-
-__END__
-
-# original
-
-NP = 5
-ROW = 8 + NP
-COL = 8
-
-$p = []
-$b = []
-$no = 0
-
-def piece(n,a,nb)
-  for x in nb
-    a[n] = x
-    if n == NP-1
-      $p << [a.sort]
-    else
-      nbc=nb.dup
-      for d in [-ROW, -1, 1, ROW]
-        if x+d > 0 and not a.include?(x+d) and not nbc.include?(x+d)
-          nbc << x+d
-        end
-      end
-      nbc.delete x
-      piece(n+1,a[0..n],nbc)
-    end
-  end
-end
-
-def kikaku(a)
-  a.collect {|x| x - a[0]}
-end
-def ud(a)
-  kikaku(a.collect {|x| ((x+NP)%ROW)-ROW*((x+NP)/ROW) }.sort)
-end
-def rl(a)
-  kikaku(a.collect {|x| ROW*((x+NP)/ROW)+ROW-((x+NP)%ROW)}.sort)
-end
-def xy(a)
-  kikaku(a.collect {|x| ROW*((x+NP)%ROW) + (x+NP)/ROW }.sort)
-end
-
-def mkpieces
-  piece(0,[],[0])
-  $p.each do |a|
-    a0 = a[0]
-    a[1] = ud(a0)
-    a[2] = rl(a0)
-    a[3] = ud(rl(a0))
-    a[4] = xy(a0)
-    a[5] = ud(xy(a0))
-    a[6] = rl(xy(a0))
-    a[7] = ud(rl(xy(a0)))
-    a.sort!
-    a.uniq!
-  end
-  $p.uniq!.sort! {|x,y| x[0] <=> y[0] }
-end
-
-def mkboard
-  for i in 0...ROW*COL
-    if i % ROW >= ROW-NP
-      $b[i] = -2
-    else
-      $b[i] = -1
-    end
-    $b[3*ROW+3]=$b[3*ROW+4]=$b[4*ROW+3]=$b[4*ROW+4]=-2
-  end
-end
-
-def pboard
-  print "No. #$no\n"
-  for i in 0...COL
-    print "|"
-    for j in 0...ROW-NP
-      x = $b[i*ROW+j]
-      if x < 0
-        print "..|"
-      else
-        printf "%2d|",x+1
-      end
-    end
-    print "\n"
-  end
-  print "\n"
-end
-
-$pnum=[]
-def setpiece(a,pos)
-  if a.length == $p.length then
-    $no += 1
-    pboard
-    return
-  end
-  while $b[pos] != -1
-    pos += 1
-  end
-  ($pnum - a).each do |i|
-    $p[i].each do |x|
-      f = 0
-      for s in x do
-        if $b[pos+s] != -1
-          f=1
-          break
-        end
-      end
-      if f == 0 then
-        for s in x do
-          $b[pos+s] = i
-        end
-        a << i
-        setpiece(a.dup, pos)
-        a.pop
-        for s in x do
-          $b[pos+s] = -1
-        end
-      end
-    end
-  end
-end
-
-mkpieces
-mkboard
-$p[4] = [$p[4][0]]
-$pnum = (0...$p.length).to_a
-setpiece([],0)
diff --git a/benchmark/bm_app_raise.rb b/benchmark/bm_app_raise.rb
deleted file mode 100644
index 5db8f95d50..0000000000
--- a/benchmark/bm_app_raise.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-i = 0
-while i<300000
-  i += 1
-  begin
-    raise
-  rescue
-  end
-end
diff --git a/benchmark/bm_app_strconcat.rb b/benchmark/bm_app_strconcat.rb
deleted file mode 100644
index 7eed7c1aed..0000000000
--- a/benchmark/bm_app_strconcat.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-i = 0
-while i<2_000_000
-  "#{1+1} #{1+1} #{1+1}"
-  i += 1
-end
diff --git a/benchmark/bm_app_tak.rb b/benchmark/bm_app_tak.rb
deleted file mode 100644
index efe5380f4e..0000000000
--- a/benchmark/bm_app_tak.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-
-def tak x, y, z
-  unless y < x
-    z
-  else
-    tak( tak(x-1, y, z),
-         tak(y-1, z, x),
-         tak(z-1, x, y))
-  end
-end
-
-tak(18, 9, 0)
-
diff --git a/benchmark/bm_app_tarai.rb b/benchmark/bm_app_tarai.rb
deleted file mode 100644
index 4c146f5ccf..0000000000
--- a/benchmark/bm_app_tarai.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-def tarai( x, y, z )
-  if x <= y
-  then y
-  else tarai(tarai(x-1, y, z),
-             tarai(y-1, z, x),
-             tarai(z-1, x, y))
-  end
-end
-
-tarai(12, 6, 0)
diff --git a/benchmark/bm_app_uri.rb b/benchmark/bm_app_uri.rb
deleted file mode 100644
index 586edfd5dc..0000000000
--- a/benchmark/bm_app_uri.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-require 'uri'
-
-100_000.times{
-  uri = URI.parse('http://www.ruby-lang.org')
-  uri.scheme
-  uri.host
-  uri.port
-}
diff --git a/benchmark/bm_array_sample_100k_10.rb b/benchmark/bm_array_sample_100k_10.rb
deleted file mode 100644
index 5f41ecc32b..0000000000
--- a/benchmark/bm_array_sample_100k_10.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-arr = [*0...100000]
-10_000.times {arr.sample 10}
diff --git a/benchmark/bm_array_sample_100k_11.rb b/benchmark/bm_array_sample_100k_11.rb
deleted file mode 100644
index 18b1715319..0000000000
--- a/benchmark/bm_array_sample_100k_11.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-arr = [*0...100000]
-10_000.times {arr.sample 11}
diff --git a/benchmark/bm_array_sample_100k__100.rb b/benchmark/bm_array_sample_100k__100.rb
deleted file mode 100644
index 22863afe89..0000000000
--- a/benchmark/bm_array_sample_100k__100.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-arr = [*0...100000]
-10_000.times {arr.sample 100}
diff --git a/benchmark/bm_array_sample_100k__1k.rb b/benchmark/bm_array_sample_100k__1k.rb
deleted file mode 100644
index 4cd79e6c67..0000000000
--- a/benchmark/bm_array_sample_100k__1k.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-arr = [*0...100000]
-10_000.times {arr.sample 1000}
diff --git a/benchmark/bm_array_sample_100k__6k.rb b/benchmark/bm_array_sample_100k__6k.rb
deleted file mode 100644
index b3d264249e..0000000000
--- a/benchmark/bm_array_sample_100k__6k.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-arr = [*0...100000]
-10_000.times {arr.sample 6000}
diff --git a/benchmark/bm_array_sample_100k___10k.rb b/benchmark/bm_array_sample_100k___10k.rb
deleted file mode 100644
index 5dd55ec058..0000000000
--- a/benchmark/bm_array_sample_100k___10k.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-arr = [*0...100000]
-10_000.times {arr.sample 10_000}
diff --git a/benchmark/bm_array_sample_100k___50k.rb b/benchmark/bm_array_sample_100k___50k.rb
deleted file mode 100644
index 1506732c3c..0000000000
--- a/benchmark/bm_array_sample_100k___50k.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-arr = [*0...100000]
-10_000.times {arr.sample 50_000}
diff --git a/benchmark/bm_array_shift.rb b/benchmark/bm_array_shift.rb
deleted file mode 100644
index 798bb9e3f4..0000000000
--- a/benchmark/bm_array_shift.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-require 'benchmark'
-
-Benchmark.bm do |x|
-  [10_000,1_000_000,100_000_000].each do |n|
-    ary = Array.new(n,0)
-    GC.start
-    x.report("#{n}:shift"){ ary.shift }
-    (0..4).each do |i|
-      ary = Array.new(n,0)
-      GC.start
-      x.report("#{n}:shift(#{i})"){ ary.shift(i) }
-    end
-  end
-end
diff --git a/benchmark/bm_array_small_and.rb b/benchmark/bm_array_small_and.rb
deleted file mode 100644
index e53a6edae6..0000000000
--- a/benchmark/bm_array_small_and.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
-MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
-ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
-
-ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
-  (MIN_SIZE..MAX_SIZE).map do |size2|
-    [Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
-  end
-end
-
-ITERATIONS.times do
-  ARRAYS.each do |group|
-    group.each do |arr1, arr2|
-      arr1 & arr2
-    end
-  end
-end
diff --git a/benchmark/bm_array_small_diff.rb b/benchmark/bm_array_small_diff.rb
deleted file mode 100644
index 9661ee48db..0000000000
--- a/benchmark/bm_array_small_diff.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
-MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
-ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
-
-ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
-  (MIN_SIZE..MAX_SIZE).map do |size2|
-    [Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
-  end
-end
-
-ITERATIONS.times do
-  ARRAYS.each do |group|
-    group.each do |arr1, arr2|
-      arr1 - arr2
-    end
-  end
-end
diff --git a/benchmark/bm_array_small_or.rb b/benchmark/bm_array_small_or.rb
deleted file mode 100644
index c58b5fd1ff..0000000000
--- a/benchmark/bm_array_small_or.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-MIN_SIZE = ENV.fetch('SMALL_ARRAY_MIN', 0).to_i
-MAX_SIZE = ENV.fetch('SMALL_ARRAY_MAX', 16).to_i
-ITERATIONS = ENV.fetch('SMALL_ARRAY_ITERATIONS', 100).to_i
-
-ARRAYS = (MIN_SIZE..MAX_SIZE).map do |size1|
-  (MIN_SIZE..MAX_SIZE).map do |size2|
-    [Array.new(size1) { rand(MAX_SIZE) }, Array.new(size2) { rand(MAX_SIZE) }]
-  end
-end
-
-ITERATIONS.times do
-  ARRAYS.each do |group|
-    group.each do |arr1, arr2|
-      arr1 | arr2
-    end
-  end
-end
diff --git a/benchmark/bm_array_sort_block.rb b/benchmark/bm_array_sort_block.rb
deleted file mode 100644
index 3579786056..0000000000
--- a/benchmark/bm_array_sort_block.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-ary = Array.new(1000) { rand(1000) }
-10000.times { ary.sort { |a, b| a <=> b } }
diff --git a/benchmark/bm_array_sort_float.rb b/benchmark/bm_array_sort_float.rb
deleted file mode 100644
index 9a6e2f8bd2..0000000000
--- a/benchmark/bm_array_sort_float.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-arr = Array.new(1000) { rand }
-10000.times { arr.sort }
diff --git a/benchmark/bm_array_values_at_int.rb b/benchmark/bm_array_values_at_int.rb
deleted file mode 100644
index 6cb394cb9f..0000000000
--- a/benchmark/bm_array_values_at_int.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-ary = Array.new(10000) {|i| i}
-100000.times { ary.values_at(500) }
diff --git a/benchmark/bm_array_values_at_range.rb b/benchmark/bm_array_values_at_range.rb
deleted file mode 100644
index 5b53806d1c..0000000000
--- a/benchmark/bm_array_values_at_range.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-ary = Array.new(10000) {|i| i}
-100000.times { ary.values_at(1..2000) }
diff --git a/benchmark/bm_bighash.rb b/benchmark/bm_bighash.rb
deleted file mode 100644
index e2ad5a5c94..0000000000
--- a/benchmark/bm_bighash.rb
+++ /dev/null
@@ -1 +0,0 @@
-h = {}; 5000000.times {|n| h[n] = n }
diff --git a/benchmark/bm_dir_empty_p.rb b/benchmark/bm_dir_empty_p.rb
deleted file mode 100644
index 8329c757cf..0000000000
--- a/benchmark/bm_dir_empty_p.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-require 'tmpdir'
-max = 100_000
-Dir.mktmpdir('bm_dir_empty_p') do |dir|
-  max.times { Dir.empty?(dir) }
-end
diff --git a/benchmark/bm_erb_render.rb b/benchmark/bm_erb_render.rb
deleted file mode 100644
index 7dc0816c43..0000000000
--- a/benchmark/bm_erb_render.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-require 'erb'
-
-data = <<erb
-<html>
-  <head> <%= title %> </head>
-  <body>
-    <h1> <%= title %> </h1>
-    <p>
-      <%= content %>
-    </p>
-  </body>
-</html>
-erb
-
-max = 1_500_000
-title = "hello world!"
-content = "hello world!\n" * 10
-
-src = "def self.render(title, content); #{ERB.new(data).src}; end"
-mod = Module.new
-mod.instance_eval(src, "(ERB)")
-
-max.times do
-  mod.render(title, content)
-end
diff --git a/benchmark/bm_file_chmod.rb b/benchmark/bm_file_chmod.rb
deleted file mode 100644
index 1cd4760c9d..0000000000
--- a/benchmark/bm_file_chmod.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# chmod file
-require 'tempfile'
-max = 200_000
-tmp = Tempfile.new('chmod')
-path = tmp.path
-max.times do
-  File.chmod(0777, path)
-end
-tmp.close!
diff --git a/benchmark/bm_file_rename.rb b/benchmark/bm_file_rename.rb
deleted file mode 100644
index 3bf6a5ef35..0000000000
--- a/benchmark/bm_file_rename.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# rename file
-require 'tempfile'
-
-max = 100_000
-tmp = [ Tempfile.new('rename-a'), Tempfile.new('rename-b') ]
-a, b = tmp.map { |x| x.path }
-max.times do
-  File.rename(a, b)
-  File.rename(b, a)
-end
-tmp.each { |t| t.close! }
diff --git a/benchmark/bm_hash_aref_dsym.rb b/benchmark/bm_hash_aref_dsym.rb
deleted file mode 100644
index af4f8c36d4..0000000000
--- a/benchmark/bm_hash_aref_dsym.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}
-syms = ('a'..'z').map { |s| s.to_sym }
-syms.each { |s| h[s] = 1 }
-200_000.times { syms.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_aref_dsym_long.rb b/benchmark/bm_hash_aref_dsym_long.rb
deleted file mode 100644
index 9d7759379e..0000000000
--- a/benchmark/bm_hash_aref_dsym_long.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# [ruby-core:70129] [Bug #11396]
-collection_size = 200000
-sample_size = 10000
-
-values = (1..collection_size).to_a.map do |x|
-  "THIS IS A LONGER STRING THAT IS ALSO UNIQUE #{x}"
-end
-
-symbol_hash = {}
-
-values.each do |x|
-  symbol_hash[x.to_sym] = 1
-end
-
-# use the same samples each time to minimize deviations
-rng = Random.new(0)
-symbol_sample_array = values.sample(sample_size, random: rng).map(&:to_sym)
-
-3000.times do
-  symbol_sample_array.each { |x| symbol_hash[x] }
-end
diff --git a/benchmark/bm_hash_aref_fix.rb b/benchmark/bm_hash_aref_fix.rb
deleted file mode 100644
index 1346890582..0000000000
--- a/benchmark/bm_hash_aref_fix.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}
-nums = (1..26).to_a
-nums.each { |i| h[i] = i }
-200_000.times { nums.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_aref_flo.rb b/benchmark/bm_hash_aref_flo.rb
deleted file mode 100644
index 2217274c82..0000000000
--- a/benchmark/bm_hash_aref_flo.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}
-strs = [*1..10000].map! {|i| i.fdiv(10)}
-strs.each { |s| h[s] = s }
-50.times { strs.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_aref_miss.rb b/benchmark/bm_hash_aref_miss.rb
deleted file mode 100644
index b0913dd4bb..0000000000
--- a/benchmark/bm_hash_aref_miss.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-h = {}
-strs = ('a'..'z').to_a.map!(&:freeze)
-strs.each { |s| h[s] = s }
-strs = ('A'..'Z').to_a
-200_000.times { strs.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_aref_str.rb b/benchmark/bm_hash_aref_str.rb
deleted file mode 100644
index 19439b061b..0000000000
--- a/benchmark/bm_hash_aref_str.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}
-strs = ('a'..'z').to_a.map!(&:freeze)
-strs.each { |s| h[s] = s }
-200_000.times { strs.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_aref_sym.rb b/benchmark/bm_hash_aref_sym.rb
deleted file mode 100644
index f75d163fe6..0000000000
--- a/benchmark/bm_hash_aref_sym.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-h = {}
-syms = ('a'..'z').to_a
-begin
-  syms = eval("%i[#{syms.join(' ')}]")
-rescue SyntaxError # <= 1.9.3
-  syms.map!(&:to_sym)
-end
-syms.each { |s| h[s] = s }
-200_000.times { syms.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_aref_sym_long.rb b/benchmark/bm_hash_aref_sym_long.rb
deleted file mode 100644
index 9dab8df7be..0000000000
--- a/benchmark/bm_hash_aref_sym_long.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-h = {}
-syms = %w[puts warn syswrite write stat bacon lettuce tomato
-some symbols in this array may already be interned  others should not be
-hash browns make good breakfast but not cooked using prime numbers
-shift for division entries delete_if keys exist?
-]
-begin
-  syms = eval("%i[#{syms.join(' ')}]")
-rescue SyntaxError # <= 1.9.3
-  syms.map!(&:to_sym)
-end
-syms.each { |s| h[s] = s }
-200_000.times { syms.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_flatten.rb b/benchmark/bm_hash_flatten.rb
deleted file mode 100644
index e944aae9f2..0000000000
--- a/benchmark/bm_hash_flatten.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-h = {}
-
-10000.times do |i|
-  h[i] = nil
-end
-
-1000.times do
-  h.flatten
-end
diff --git a/benchmark/bm_hash_ident_flo.rb b/benchmark/bm_hash_ident_flo.rb
deleted file mode 100644
index 0c7edfed3e..0000000000
--- a/benchmark/bm_hash_ident_flo.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}.compare_by_identity
-strs = (1..10000).to_a.map!(&:to_f)
-strs.each { |s| h[s] = s }
-50.times { strs.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_ident_num.rb b/benchmark/bm_hash_ident_num.rb
deleted file mode 100644
index b226736c6f..0000000000
--- a/benchmark/bm_hash_ident_num.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}.compare_by_identity
-nums = (1..26).to_a
-nums.each { |n| h[n] = n }
-200_000.times { nums.each { |n| h[n] } }
diff --git a/benchmark/bm_hash_ident_obj.rb b/benchmark/bm_hash_ident_obj.rb
deleted file mode 100644
index 4b3b58edec..0000000000
--- a/benchmark/bm_hash_ident_obj.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}.compare_by_identity
-objs = 26.times.map { Object.new }
-objs.each { |o| h[o] = o }
-200_000.times { objs.each { |o| h[o] } }
diff --git a/benchmark/bm_hash_ident_str.rb b/benchmark/bm_hash_ident_str.rb
deleted file mode 100644
index 8582b38e31..0000000000
--- a/benchmark/bm_hash_ident_str.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}.compare_by_identity
-strs = ('a'..'z').to_a
-strs.each { |s| h[s] = s }
-200_000.times { strs.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_ident_sym.rb b/benchmark/bm_hash_ident_sym.rb
deleted file mode 100644
index 4c81e3d28e..0000000000
--- a/benchmark/bm_hash_ident_sym.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-h = {}.compare_by_identity
-syms = ('a'..'z').to_a.map(&:to_sym)
-syms.each { |s| h[s] = s }
-200_000.times { syms.each { |s| h[s] } }
diff --git a/benchmark/bm_hash_keys.rb b/benchmark/bm_hash_keys.rb
deleted file mode 100644
index 6863cd01f9..0000000000
--- a/benchmark/bm_hash_keys.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-h = {}
-
-10000.times do |i|
-  h[i] = nil
-end
-
-5000.times do
-  h.keys
-end
diff --git a/benchmark/bm_hash_long.rb b/benchmark/bm_hash_long.rb
deleted file mode 100644
index 03d9109602..0000000000
--- a/benchmark/bm_hash_long.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-k1 = "Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong";
-k2 = "Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping";
-h = {k1 => 0, k2 => 0};
-3000000.times{|i| k = i % 2 ? k2 : k1; h [k] = h[k] + 1}
diff --git a/benchmark/bm_hash_shift.rb b/benchmark/bm_hash_shift.rb
deleted file mode 100644
index a645671a5b..0000000000
--- a/benchmark/bm_hash_shift.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-h = {}
-
-10000.times do |i|
-  h[i] = nil
-end
-
-50000.times do
-  k, v = h.shift
-  h[k] = v
-end
diff --git a/benchmark/bm_hash_shift_u16.rb b/benchmark/bm_hash_shift_u16.rb
deleted file mode 100644
index ec800d0342..0000000000
--- a/benchmark/bm_hash_shift_u16.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-h = {}
-
-(16384..65536).each do |i|
-  h[i] = nil
-end
-
-300000.times do
-  k, v = h.shift
-  h[k] = v
-end
diff --git a/benchmark/bm_hash_shift_u24.rb b/benchmark/bm_hash_shift_u24.rb
deleted file mode 100644
index de4e0fa696..0000000000
--- a/benchmark/bm_hash_shift_u24.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-h = {}
-
-(0xff4000..0xffffff).each do |i|
-  h[i] = nil
-end
-
-300000.times do
-  k, v = h.shift
-  h[k] = v
-end
diff --git a/benchmark/bm_hash_shift_u32.rb b/benchmark/bm_hash_shift_u32.rb
deleted file mode 100644
index 656aa55583..0000000000
--- a/benchmark/bm_hash_shift_u32.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-h = {}
-
-(0xffff4000..0xffffffff).each do |i|
-  h[i] = nil
-end
-
-300000.times do
-  k, v = h.shift
-  h[k] = v
-end
diff --git a/benchmark/bm_hash_small2.rb b/benchmark/bm_hash_small2.rb
deleted file mode 100644
index 45485d9c71..0000000000
--- a/benchmark/bm_hash_small2.rb
+++ /dev/null
@@ -1 +0,0 @@
-1000000.times.map{|i| a={}; 2.times{|j| a[j]=j}; a}
diff --git a/benchmark/bm_hash_small4.rb b/benchmark/bm_hash_small4.rb
deleted file mode 100644
index acd4084334..0000000000
--- a/benchmark/bm_hash_small4.rb
+++ /dev/null
@@ -1 +0,0 @@
-1000000.times.map{|i| a={}; 4.times{|j| a[j]=j}; a}
diff --git a/benchmark/bm_hash_small8.rb b/benchmark/bm_hash_small8.rb
deleted file mode 100644
index 9cffcc91b6..0000000000
--- a/benchmark/bm_hash_small8.rb
+++ /dev/null
@@ -1 +0,0 @@
-1000000.times.map{|i| a={}; 8.times{|j| a[j]=j}; a}
diff --git a/benchmark/bm_hash_to_proc.rb b/benchmark/bm_hash_to_proc.rb
deleted file mode 100644
index 2b675bf509..0000000000
--- a/benchmark/bm_hash_to_proc.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-h = {}
-
-10000.times do |i|
-  h[i] = nil
-end
-
-5000.times do |i|
-  [i].map(&h)
-end
diff --git a/benchmark/bm_hash_values.rb b/benchmark/bm_hash_values.rb
deleted file mode 100644
index 069441302f..0000000000
--- a/benchmark/bm_hash_values.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-h = {}
-
-10000.times do |i|
-  h[i] = nil
-end
-
-5000.times do
-  h.values
-end
diff --git a/benchmark/bm_int_quo.rb b/benchmark/bm_int_quo.rb
deleted file mode 100644
index e22a3f8c30..0000000000
--- a/benchmark/bm_int_quo.rb
+++ /dev/null
@@ -1 +0,0 @@
-5000000.times { 42.quo(3) }
diff --git a/benchmark/bm_io_copy_stream_write.rb b/benchmark/bm_io_copy_stream_write.rb
deleted file mode 100644
index 3fd87250a4..0000000000
--- a/benchmark/bm_io_copy_stream_write.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-# The goal of this is to use a synthetic (non-IO) reader
-# to trigger the read/write loop of IO.copy_stream,
-# bypassing in-kernel mechanisms like sendfile for zero copy,
-# so we wrap the /dev/zero IO object:
-
-class Zero
-  def initialize
-    @n = 100000
-    @in = File.open('/dev/zero', 'rb')
-  end
-
-  def read(len, buf)
-    return if (@n -= 1) == 0
-    @in.read(len, buf)
-  end
-end
-
-begin
-  src = Zero.new
-  dst = File.open(IO::NULL, 'wb')
-  n = IO.copy_stream(src, dst)
-rescue Errno::ENOENT
-  # not *nix
-end if IO.respond_to?(:copy_stream) && IO.const_defined?(:NULL)
diff --git a/benchmark/bm_io_copy_stream_write_socket.rb b/benchmark/bm_io_copy_stream_write_socket.rb
deleted file mode 100644
index 11f369bd0d..0000000000
--- a/benchmark/bm_io_copy_stream_write_socket.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# The goal of this is to use a synthetic (non-IO) reader
-# to trigger the read/write loop of IO.copy_stream,
-# bypassing in-kernel mechanisms like sendfile for zero copy,
-# so we wrap the /dev/zero IO object:
-class Zero
-  def initialize
-    @n = 100000
-    @in = File.open('/dev/zero', 'rb')
-  end
-
-  def read(len, buf)
-    return if (@n -= 1) == 0
-    @in.read(len, buf)
-  end
-end
-
-begin
-  require 'socket'
-  src = Zero.new
-  rd, wr = UNIXSocket.pair
-  pid = fork do
-    wr.close
-    buf = String.new
-    while rd.read(16384, buf)
-    end
-  end
-  rd.close
-  IO.copy_stream(src, wr)
-rescue Errno::ENOENT, NotImplementedError, NameError
-  # not *nix: missing /dev/zero, fork, or UNIXSocket
-rescue LoadError # no socket?
-ensure
-  wr.close if wr
-  Process.waitpid(pid) if pid
-end if IO.respond_to?(:copy_stream)
diff --git a/benchmark/bm_io_file_create.rb b/benchmark/bm_io_file_create.rb
deleted file mode 100644
index 2f205c1333..0000000000
--- a/benchmark/bm_io_file_create.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-#
-# Create files
-#
-
-max = 200_000
-file = './tmpfile_of_bm_io_file_create'
-
-max.times{
-  f = open(file, 'w')
-  f.close#(true)
-}
-File.unlink(file)
-
diff --git a/benchmark/bm_io_file_read.rb b/benchmark/bm_io_file_read.rb
deleted file mode 100644
index b9e796ed30..0000000000
--- a/benchmark/bm_io_file_read.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-#
-# Seek and Read file.
-#
-
-require 'tempfile'
-
-max = 200_000
-str = "Hello world!  " * 1000
-f = Tempfile.new('yarv-benchmark')
-f.write str
-
-max.times{
-  f.seek 0
-  f.read
-}
diff --git a/benchmark/bm_io_file_write.rb b/benchmark/bm_io_file_write.rb
deleted file mode 100644
index aa1be0e5fe..0000000000
--- a/benchmark/bm_io_file_write.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-#
-# Seek and Write file.
-#
-
-require 'tempfile'
-
-max = 200_000
-str = "Hello world!  " * 1000
-f = Tempfile.new('yarv-benchmark')
-
-max.times{
-  f.seek 0
-  f.write str
-}
diff --git a/benchmark/bm_io_nonblock_noex.rb b/benchmark/bm_io_nonblock_noex.rb
deleted file mode 100644
index da9357fdc6..0000000000
--- a/benchmark/bm_io_nonblock_noex.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-nr = 1_000_000
-i = 0
-msg = '.'
-buf = '.'
-noex = { exception: false }
-begin
-  r, w = IO.pipe
-  while i < nr
-    i += 1
-    w.write_nonblock(msg, noex)
-    r.read_nonblock(1, buf, noex)
-  end
-rescue ArgumentError # old Rubies
-  while i < nr
-    i += 1
-    w.write_nonblock(msg)
-    r.read_nonblock(1, buf)
-  end
-ensure
-  r.close
-  w.close
-end
diff --git a/benchmark/bm_io_nonblock_noex2.rb b/benchmark/bm_io_nonblock_noex2.rb
deleted file mode 100644
index 56819d049b..0000000000
--- a/benchmark/bm_io_nonblock_noex2.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-nr = 1_000_000
-i = 0
-msg = '.'
-buf = '.'
-begin
-  r, w = IO.pipe
-  while i < nr
-    i += 1
-    w.write_nonblock(msg, exception: false)
-    r.read_nonblock(1, buf, exception: false)
-  end
-rescue ArgumentError # old Rubies
-  while i < nr
-    i += 1
-    w.write_nonblock(msg)
-    r.read_nonblock(1, buf)
-  end
-ensure
-  r.close
-  w.close
-end
diff --git a/benchmark/bm_io_pipe_rw.rb b/benchmark/bm_io_pipe_rw.rb
deleted file mode 100644
index 6862a8ae61..0000000000
--- a/benchmark/bm_io_pipe_rw.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-# Measure uncontended GVL performance via read/write with 1:1 threading
-# If we switch to M:N threading, this will benchmark something else...
-r, w = IO.pipe
-src = '0'.freeze
-dst = String.new
-i = 0
-while i < 1_000_000
-  i += 1
-  w.write(src)
-  r.read(1, dst)
-end
-w.close
-r.close
diff --git a/benchmark/bm_io_select.rb b/benchmark/bm_io_select.rb
deleted file mode 100644
index 19248daeb1..0000000000
--- a/benchmark/bm_io_select.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# IO.select performance
-
-w = [ IO.pipe[1] ];
-
-nr = 1000000
-nr.times {
-  IO.select nil, w
-}
-
diff --git a/benchmark/bm_io_select2.rb b/benchmark/bm_io_select2.rb
deleted file mode 100644
index 10e37d71b2..0000000000
--- a/benchmark/bm_io_select2.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# IO.select performance. worst case of single fd.
-
-ios = []
-nr = 1000000
-if defined?(Process::RLIMIT_NOFILE)
-  max = Process.getrlimit(Process::RLIMIT_NOFILE)[0]
-else
-  max = 64
-end
-puts "max fd: #{max} (results not apparent with <= 1024 max fd)"
-
-((max / 2) - 10).times do
-  ios.concat IO.pipe
-end
-
-last = [ ios[-1] ]
-puts "last IO: #{last[0].inspect}"
-
-nr.times do
-  IO.select nil, last
-end
-
diff --git a/benchmark/bm_io_select3.rb b/benchmark/bm_io_select3.rb
deleted file mode 100644
index 7d0ba1f092..0000000000
--- a/benchmark/bm_io_select3.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# IO.select performance. a lot of fd
-
-ios = []
-nr = 100
-if defined?(Process::RLIMIT_NOFILE)
-  max = Process.getrlimit(Process::RLIMIT_NOFILE)[0]
-else
-  max = 64
-end
-puts "max fd: #{max} (results not apparent with <= 1024 max fd)"
-
-(max - 10).times do
-  r, w = IO.pipe
-  r.close
-  ios.push w
-end
-
-nr.times do
-  IO.select nil, ios
-end
-
diff --git a/benchmark/bm_loop_for.rb b/benchmark/bm_loop_for.rb
deleted file mode 100644
index 0fc4cc1511..0000000000
--- a/benchmark/bm_loop_for.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-for i in 1..30_000_000
-  #
-end
diff --git a/benchmark/bm_loop_generator.rb b/benchmark/bm_loop_generator.rb
deleted file mode 100644
index d3375c744c..0000000000
--- a/benchmark/bm_loop_generator.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-max = 600000
-
-if defined? Fiber
-  gen = (1..max).each
-  loop do
-    gen.next
-  end
-else
-  require 'generator'
-  gen = Generator.new((0..max))
-  while gen.next?
-    gen.next
-  end
-end
diff --git a/benchmark/bm_loop_times.rb b/benchmark/bm_loop_times.rb
deleted file mode 100644
index 521f72ad1a..0000000000
--- a/benchmark/bm_loop_times.rb
+++ /dev/null
@@ -1 +0,0 @@
-30_000_000.times{|e|}
diff --git a/benchmark/bm_loop_whileloop.rb b/benchmark/bm_loop_whileloop.rb
deleted file mode 100644
index 0072822c06..0000000000
--- a/benchmark/bm_loop_whileloop.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-i = 0
-while i<30_000_000 # benchmark loop 1
-  i += 1
-end
diff --git a/benchmark/bm_loop_whileloop2.rb b/benchmark/bm_loop_whileloop2.rb
deleted file mode 100644
index 47d02dffc4..0000000000
--- a/benchmark/bm_loop_whileloop2.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-i = 0
-while i< 6_000_000 # benchmark loop 2
-  i += 1
-end
diff --git a/benchmark/bm_marshal_dump_flo.rb b/benchmark/bm_marshal_dump_flo.rb
deleted file mode 100644
index 9b8d0c6afb..0000000000
--- a/benchmark/bm_marshal_dump_flo.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-bug10761 = 10000.times.map { |x| x.to_f }
-100.times { Marshal.dump(bug10761) }
diff --git a/benchmark/bm_marshal_dump_load_geniv.rb b/benchmark/bm_marshal_dump_load_geniv.rb
deleted file mode 100644
index 8252ad90fa..0000000000
--- a/benchmark/bm_marshal_dump_load_geniv.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-a = ''
-a.instance_eval do
-  @a = :a
-  @b = :b
-  @c = :c
-end
-100000.times do
-  a = Marshal.load(Marshal.dump(a))
-end
-#p(a.instance_eval { @a == :a && @b == :b && @c == :c })
diff --git a/benchmark/bm_marshal_dump_load_time.rb b/benchmark/bm_marshal_dump_load_time.rb
deleted file mode 100644
index e29743b791..0000000000
--- a/benchmark/bm_marshal_dump_load_time.rb
+++ /dev/null
@@ -1 +0,0 @@
-100000.times { Marshal.load(Marshal.dump(Time.now)) }
diff --git a/benchmark/bm_securerandom.rb b/benchmark/bm_securerandom.rb
deleted file mode 100644
index a082ea6d5b..0000000000
--- a/benchmark/bm_securerandom.rb
+++ /dev/null
@@ -1,5 +0,0 @@
-require "securerandom"
-
-20_0000.times do
-  SecureRandom.random_number(100)
-end
diff --git a/benchmark/bm_so_ackermann.rb b/benchmark/bm_so_ackermann.rb
deleted file mode 100644
index 7db5be9050..0000000000
--- a/benchmark/bm_so_ackermann.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/usr/bin/ruby
-# -*- mode: ruby -*-
-# $Id: ackermann-ruby.code,v 1.4 2004/11/13 07:40:41 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-
-def ack(m, n)
-    if m == 0 then
-        n + 1
-    elsif n == 0 then
-        ack(m - 1, 1)
-    else
-        ack(m - 1, ack(m, n - 1))
-    end
-end
-
-NUM = 9
-ack(3, NUM)
-
-
diff --git a/benchmark/bm_so_array.rb b/benchmark/bm_so_array.rb
deleted file mode 100644
index 2b8fce8f99..0000000000
--- a/benchmark/bm_so_array.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/ruby
-# -*- mode: ruby -*-
-# $Id: ary-ruby.code,v 1.4 2004/11/13 07:41:27 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-# with help from Paul Brannan and Mark Hubbart
-
-n = 9000 # Integer(ARGV.shift || 1)
-
-x = Array.new(n)
-y = Array.new(n, 0)
-
-n.times{|bi|
-  x[bi] = bi + 1
-}
-
-(0 .. 999).each do |e|
-  (n-1).step(0,-1) do |bi|
-    y[bi] += x.at(bi)
-  end
-end
-# puts "#{y.first} #{y.last}"
-
-
diff --git a/benchmark/bm_so_binary_trees.rb b/benchmark/bm_so_binary_trees.rb
deleted file mode 100644
index b1693e4109..0000000000
--- a/benchmark/bm_so_binary_trees.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-# The Computer Language Shootout Benchmarks
-# http://shootout.alioth.debian.org
-#
-# contributed by Jesse Millikan
-
-# disable output
-alias puts_orig puts
-def puts str
-  # disable puts
-end
-
-def item_check(tree)
- if tree[0] == nil
-  tree[1]
- else
-  tree[1] + item_check(tree[0]) - item_check(tree[2])
- end
-end
-
-def bottom_up_tree(item, depth)
- if depth > 0
-  item_item = 2 * item
-  depth -= 1
-  [bottom_up_tree(item_item - 1, depth), item, bottom_up_tree(item_item, depth)]
- else
-  [nil, item, nil]
- end
-end
-
-max_depth = 16 # ARGV[0].to_i
-min_depth = 4
-
-max_depth = min_depth + 2 if min_depth + 2 > max_depth
-
-stretch_depth = max_depth + 1
-stretch_tree = bottom_up_tree(0, stretch_depth)
-
-puts "stretch tree of depth #{stretch_depth}\t check: #{item_check(stretch_tree)}"
-stretch_tree = nil
-
-long_lived_tree = bottom_up_tree(0, max_depth)
-
-min_depth.step(max_depth + 1, 2) do |depth|
- iterations = 2**(max_depth - depth + min_depth)
-
- check = 0
-
- for i in 1..iterations
-  temp_tree = bottom_up_tree(i, depth)
-  check += item_check(temp_tree)
-
-  temp_tree = bottom_up_tree(-i, depth)
-  check += item_check(temp_tree)
- end
-
- puts "#{iterations * 2}\t trees of depth #{depth}\t check: #{check}"
-end
-
-puts "long lived tree of depth #{max_depth}\t check: #{item_check(long_lived_tree)}"
-
-undef puts
-alias puts puts_orig
diff --git a/benchmark/bm_so_concatenate.rb b/benchmark/bm_so_concatenate.rb
deleted file mode 100644
index 873214de7c..0000000000
--- a/benchmark/bm_so_concatenate.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/ruby
-# -*- mode: ruby -*-
-# $Id: strcat-ruby.code,v 1.4 2004/11/13 07:43:28 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-# based on code from Aristarkh A Zagorodnikov and Dat Nguyen
-
-STUFF = "hello\n"
-i = 0
-while i<10
-  i += 1
-  hello = ''
-  4_000_000.times do |e|
-    hello << STUFF
-  end
-end
-# puts hello.length
-
-
diff --git a/benchmark/bm_so_exception.rb b/benchmark/bm_so_exception.rb
deleted file mode 100644
index deb003a594..0000000000
--- a/benchmark/bm_so_exception.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/usr/bin/ruby
-# -*- mode: ruby -*-
-# $Id: except-ruby.code,v 1.4 2004/11/13 07:41:33 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-
-$HI = 0
-$LO = 0
-NUM = 250000 # Integer(ARGV[0] || 1)
-
-
-class Lo_Exception < Exception
-  def initialize(num)
-    @value = num
-  end
-end
-
-class Hi_Exception < Exception
-  def initialize(num)
-    @value = num
-  end
-end
-
-def some_function(num)
-  begin
-    hi_function(num)
-  rescue
-    print "We shouldn't get here, exception is: #{$!.type}\n"
-  end
-end
-
-def hi_function(num)
-  begin
-    lo_function(num)
-  rescue Hi_Exception
-    $HI = $HI + 1
-  end
-end
-
-def lo_function(num)
-  begin
-    blowup(num)
-  rescue Lo_Exception
-    $LO = $LO + 1
-  end
-end
-
-def blowup(num)
-  if num % 2 == 0
-    raise Lo_Exception.new(num)
-  else
-    raise Hi_Exception.new(num)
-  end
-end
-
-
-i = 1
-max = NUM+1
-while i < max
-  i += 1
-  some_function(i+1)
-end
diff --git a/benchmark/bm_so_fannkuch.rb b/benchmark/bm_so_fannkuch.rb
deleted file mode 100644
index bac5ecd44c..0000000000
--- a/benchmark/bm_so_fannkuch.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-# The Computer Language Shootout
-# http://shootout.alioth.debian.org/
-# Contributed by Sokolov Yura
-# Modified by Ryan Williams
-
-def fannkuch(n)
-   maxFlips, m, r, check = 0, n-1, n, 0
-   count = (1..n).to_a
-   perm = (1..n).to_a
-
-   while true
-      if check < 30
-         puts "#{perm}"
-         check += 1
-      end
-
-      while r != 1
-         count[r-1] = r
-         r -= 1
-      end
-
-      if perm[0] != 1 and perm[m] != n
-         perml = perm.clone #.dup
-         flips = 0
-         while (k = perml.first ) != 1
-            perml = perml.slice!(0, k).reverse + perml
-            flips += 1
-         end
-         maxFlips = flips if flips > maxFlips
-      end
-      while true
-         if r==n then return maxFlips end
-         perm.insert r,perm.shift
-         break if (count[r] -= 1) > 0
-         r += 1
-      end
-   end
-end
-
-def puts *args
-end
-
-N = 9 # (ARGV[0] || 1).to_i
-puts "Pfannkuchen(#{N}) = #{fannkuch(N)}"
-
diff --git a/benchmark/bm_so_fasta.rb b/benchmark/bm_so_fasta.rb
deleted file mode 100644
index dcc6b39507..0000000000
--- a/benchmark/bm_so_fasta.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# The Computer Language Shootout
-# http://shootout.alioth.debian.org/
-# Contributed by Sokolov Yura
-
-$last = 42.0
-def gen_random(max, im=139968, ia=3877, ic=29573)
-    (max * ($last = ($last * ia + ic) % im)) / im
-end
-
-alu =
-   "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"+
-   "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"+
-   "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"+
-   "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"+
-   "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"+
-   "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"+
-   "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
-
-iub = [
-    ["a", 0.27],
-    ["c", 0.12],
-    ["g", 0.12],
-    ["t", 0.27],
-
-    ["B", 0.02],
-    ["D", 0.02],
-    ["H", 0.02],
-    ["K", 0.02],
-    ["M", 0.02],
-    ["N", 0.02],
-    ["R", 0.02],
-    ["S", 0.02],
-    ["V", 0.02],
-    ["W", 0.02],
-    ["Y", 0.02],
-]
-homosapiens = [
-    ["a", 0.3029549426680],
-    ["c", 0.1979883004921],
-    ["g", 0.1975473066391],
-    ["t", 0.3015094502008],
-]
-
-def make_repeat_fasta(id, desc, src, n)
-    puts ">#{id} #{desc}"
-    v = nil
-    width = 60
-    l = src.length
-    s = src * ((n / l) + 1)
-    s.slice!(n, l)
-    puts(s.scan(/.{1,#{width}}/).join("\n"))
-end
-
-def make_random_fasta(id, desc, table, n)
-    puts ">#{id} #{desc}"
-    rand, v = nil,nil
-    width = 60
-    chunk = 1 * width
-    prob = 0.0
-    table.each{|v| v[1]= (prob += v[1])}
-    for i in 1..(n/width)
-        puts((1..width).collect{
-            rand = gen_random(1.0)
-            table.find{|v| v[1]>rand}[0]
-        }.join)
-    end
-    if n%width != 0
-        puts((1..(n%width)).collect{
-            rand = gen_random(1.0)
-            table.find{|v| v[1]>rand}[0]
-        }.join)
-    end
-end
-
-
-n = (ARGV[0] or 250_000).to_i
-
-make_repeat_fasta('ONE', 'Homo sapiens alu', alu, n*2)
-make_random_fasta('TWO', 'IUB ambiguity codes', iub, n*3)
-make_random_fasta('THREE', 'Homo sapiens frequency', homosapiens, n*5)
-
diff --git a/benchmark/bm_so_lists.rb b/benchmark/bm_so_lists.rb
deleted file mode 100644
index e8f4a2a5f7..0000000000
--- a/benchmark/bm_so_lists.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
-
-NUM = 300
-SIZE = 10000
-
-def test_lists()
-  # create a list of integers (Li1) from 1 to SIZE
-  li1 = (1..SIZE).to_a
-  # copy the list to li2 (not by individual items)
-  li2 = li1.dup
-  # remove each individual item from left side of li2 and
-  # append to right side of li3 (preserving order)
-  li3 = Array.new
-  while (not li2.empty?)
-    li3.push(li2.shift)
-  end
-  # li2 must now be empty
-  # remove each individual item from right side of li3 and
-  # append to right side of li2 (reversing list)
-  while (not li3.empty?)
-    li2.push(li3.pop)
-  end
-  # li3 must now be empty
-  # reverse li1 in place
-  li1.reverse!
-  # check that first item is now SIZE
-  if li1[0] != SIZE then
-    p "not SIZE"
-    0
-  else
-    # compare li1 and li2 for equality
-    if li1 != li2 then
-      return(0)
-    else
-      # return the length of the list
-      li1.length
-    end
-  end
-end
-
-i = 0
-while i<NUM
-  i += 1
-  result = test_lists()
-end
-
-result
diff --git a/benchmark/bm_so_mandelbrot.rb b/benchmark/bm_so_mandelbrot.rb
deleted file mode 100644
index 76331c64b8..0000000000
--- a/benchmark/bm_so_mandelbrot.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-#  The Computer Language Benchmarks Game
-#  http://shootout.alioth.debian.org/
-#
-#  contributed by Karl von Laudermann
-#  modified by Jeremy Echols
-
-size = 600 # ARGV[0].to_i
-
-puts "P4\n#{size} #{size}"
-
-ITER = 49                           # Iterations - 1 for easy for..in looping
-LIMIT_SQUARED = 4.0                 # Presquared limit
-
-byte_acc = 0
-bit_num = 0
-
-count_size = size - 1               # Precomputed size for easy for..in looping
-
-# For..in loops are faster than .upto, .downto, .times, etc.
-for y in 0..count_size
-  for x in 0..count_size
-    zr = 0.0
-    zi = 0.0
-    cr = (2.0*x/size)-1.5
-    ci = (2.0*y/size)-1.0
-    escape = false
-
-    # To make use of the for..in code, we use a dummy variable,
-    # like one would in C
-    for dummy in 0..ITER
-      tr = zr*zr - zi*zi + cr
-      ti = 2*zr*zi + ci
-      zr, zi = tr, ti
-
-      if (zr*zr+zi*zi) > LIMIT_SQUARED
-        escape = true
-        break
-      end
-    end
-
-    byte_acc = (byte_acc << 1) | (escape ? 0b0 : 0b1)
-    bit_num += 1
-
-    # Code is very similar for these cases, but using separate blocks
-    # ensures we skip the shifting when it's unnecessary, which is most cases.
-    if (bit_num == 8)
-      print byte_acc.chr
-      byte_acc = 0
-      bit_num = 0
-    elsif (x == count_size)
-      byte_acc <<= (8 - bit_num)
-      print byte_acc.chr
-      byte_acc = 0
-      bit_num = 0
-    end
-  end
-end
diff --git a/benchmark/bm_so_matrix.rb b/benchmark/bm_so_matrix.rb
deleted file mode 100644
index e2c5c8e559..0000000000
--- a/benchmark/bm_so_matrix.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/usr/bin/ruby
-# -*- mode: ruby -*-
-# $Id: matrix-ruby.code,v 1.4 2004/11/13 07:42:14 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-
-n = 60 #Integer(ARGV.shift || 1)
-
-size = 40
-
-def mkmatrix(rows, cols)
-    count = 1
-    mx = Array.new(rows)
-    (0 .. (rows - 1)).each do |bi|
-        row = Array.new(cols, 0)
-        (0 .. (cols - 1)).each do |j|
-            row[j] = count
-            count += 1
-        end
-        mx[bi] = row
-    end
-    mx
-end
-
-def mmult(rows, cols, m1, m2)
-    m3 = Array.new(rows)
-    (0 .. (rows - 1)).each do |bi|
-        row = Array.new(cols, 0)
-        (0 .. (cols - 1)).each do |j|
-            val = 0
-            (0 .. (cols - 1)).each do |k|
-                val += m1.at(bi).at(k) * m2.at(k).at(j)
-            end
-            row[j] = val
-        end
-        m3[bi] = row
-    end
-    m3
-end
-
-m1 = mkmatrix(size, size)
-m2 = mkmatrix(size, size)
-mm = Array.new
-n.times do
-    mm = mmult(size, size, m1, m2)
-end
-# puts "#{mm[0][0]} #{mm[2][3]} #{mm[3][2]} #{mm[4][4]}"
-
-
diff --git a/benchmark/bm_so_meteor_contest.rb b/benchmark/bm_so_meteor_contest.rb
deleted file mode 100755
index 8c136baa6c..0000000000
--- a/benchmark/bm_so_meteor_contest.rb
+++ /dev/null
@@ -1,563 +0,0 @@
-#!/usr/bin/env ruby
-#
-# The Computer Language Shootout
-#   http://shootout.alioth.debian.org
-#   contributed by Kevin Barnes (Ruby novice)
-
-# PROGRAM:  the main body is at the bottom.
-#   1) read about the problem here: http://www-128.ibm.com/developerworks/java/library/j-javaopt/
-#   2) see how I represent a board as a bitmask by reading the blank_board comments
-#   3) read as your mental paths take you
-
-def print *args
-end
-
-# class to represent all information about a particular rotation of a particular piece
-class Rotation
-  # an array (by location) containing a bit mask for how the piece maps at the given location.
-  # if the rotation is invalid at that location the mask will contain false
-  attr_reader :start_masks
-
-  # maps a direction to a relative location.  these differ depending on whether it is an even or
-  # odd row being mapped from
-  @@rotation_even_adder = { :west => -1, :east => 1, :nw => -7, :ne => -6, :sw => 5, :se => 6 }
-  @@rotation_odd_adder = { :west => -1, :east => 1, :nw => -6, :ne => -5, :sw => 6, :se => 7 }
-
-  def initialize( directions )
-    @even_offsets, @odd_offsets = normalize_offsets( get_values( directions ))
-
-    @even_mask = mask_for_offsets( @even_offsets)
-    @odd_mask = mask_for_offsets( @odd_offsets)
-
-    @start_masks = Array.new(60)
-
-    # create the rotational masks by placing the base mask at the location and seeing if
-    # 1) it overlaps the boundaries and 2) it produces a prunable board.  if either of these
-    # is true the piece cannot be placed
-    0.upto(59) do | offset |
-      mask = is_even(offset) ? (@even_mask << offset) : (@odd_mask << offset)
-      if (blank_board & mask == 0 && !prunable(blank_board | mask, 0, true)) then
-        imask = compute_required( mask, offset)
-        @start_masks[offset] = [ mask, imask, imask | mask ]
-      else
-        @start_masks[offset] = false
-      end
-    end
-  end
-
-  def compute_required( mask, offset )
-    board = blank_board
-    0.upto(offset) { | i | board |= 1 << i }
-    board |= mask
-    return 0 if (!prunable(board | mask, offset))
-    board = flood_fill(board,58)
-    count = 0
-    imask = 0
-    0.upto(59) do | i |
-      if (board[i] == 0) then
-        imask |= (1 << i)
-        count += 1
-      end
-    end
-    (count > 0 && count < 5) ? imask : 0
-  end
-
-  def flood_fill( board, location)
-    return board if (board[location] == 1)
-    board |= 1 << location
-    row, col = location.divmod(6)
-    board = flood_fill( board, location - 1) if (col > 0)
-    board = flood_fill( board, location + 1) if (col < 4)
-    if (row % 2 == 0) then
-      board = flood_fill( board, location - 7) if (col > 0 && row > 0)
-      board = flood_fill( board, location - 6) if (row > 0)
-      board = flood_fill( board, location + 6) if (row < 9)
-      board = flood_fill( board, location + 5) if (col > 0 && row < 9)
-    else
-      board = flood_fill( board, location - 5) if (col < 4 && row > 0)
-      board = flood_fill( board, location - 6) if (row > 0)
-      board = flood_fill( board, location + 6) if (row < 9)
-      board = flood_fill( board, location + 7) if (col < 4 && row < 9)
-    end
-    board
-  end
-
-  # given a location, produces a list of relative locations covered by the piece at this rotation
-  def offsets( location)
-    if is_even( location) then
-      @even_offsets.collect { | value | value + location }
-    else
-      @odd_offsets.collect { | value | value + location }
-    end
-  end
-
-  # returns a set of offsets relative to the top-left most piece of the rotation (by even or odd rows)
-  # this is hard to explain. imagine we have this partial board:
-  #   0 0 0 0 0 x        [positions 0-5]
-  #    0 0 1 1 0 x       [positions 6-11]
-  #   0 0 1 0 0 x        [positions 12-17]
-  #    0 1 0 0 0 x       [positions 18-23]
-  #   0 1 0 0 0 x        [positions 24-29]
-  #    0 0 0 0 0 x       [positions 30-35]
-  #       ...
-  # The top-left of the piece is at position 8, the
-  # board would be passed as a set of positions (values array) containing [8,9,14,19,25] not necessarily in that
-  # sorted order.  Since that array starts on an odd row, the offsets for an odd row are: [0,1,6,11,17] obtained
-  # by subtracting 8 from everything.  Now imagine the piece shifted up and to the right so it's on an even row:
-  #   0 0 0 1 1 x        [positions 0-5]
-  #    0 0 1 0 0 x       [positions 6-11]
-  #   0 0 1 0 0 x        [positions 12-17]
-  #    0 1 0 0 0 x       [positions 18-23]
-  #   0 0 0 0 0 x        [positions 24-29]
-  #    0 0 0 0 0 x       [positions 30-35]
-  #       ...
-  # Now the positions are [3,4,8,14,19] which after subtracting the lowest value (3) gives [0,1,5,11,16] thus, the
-  # offsets for this particular piece are (in even, odd order) [0,1,5,11,16],[0,1,6,11,17] which is what
-  # this function would return
-  def normalize_offsets( values)
-    min = values.min
-    even_min = is_even(min)
-    other_min = even_min ? min + 6 : min + 7
-    other_values = values.collect do | value |
-      if is_even(value) then
-        value + 6 - other_min
-      else
-        value + 7 - other_min
-      end
-    end
-    values.collect! { | value | value - min }
-
-    if even_min then
-      [values, other_values]
-    else
-      [other_values, values]
-    end
-  end
-
-  # produce a bitmask representation of an array of offset locations
-  def mask_for_offsets( offsets )
-    mask = 0
-    offsets.each { | value | mask = mask + ( 1 << value ) }
-    mask
-  end
-
-  # finds a "safe" position that a position as described by a list of directions can be placed
-  # without falling off any edge of the board.  the values returned a location to place the first piece
-  # at so it will fit after making the described moves
-  def start_adjust( directions )
-    south = east = 0;
-    directions.each do | direction |
-      east += 1 if ( direction == :sw || direction == :nw || direction == :west )
-      south += 1 if ( direction == :nw || direction == :ne )
-    end
-    south * 6 + east
-  end
-
-  # given a set of directions places the piece (as defined by a set of directions) on the board at
-  # a location that will not take it off the edge
-  def get_values( directions )
-    start = start_adjust(directions)
-    values = [ start ]
-    directions.each do | direction |
-      if (start % 12 >= 6) then
-        start += @@rotation_odd_adder[direction]
-      else
-        start += @@rotation_even_adder[direction]
-      end
-      values += [ start ]
-    end
-
-    # some moves take you back to an existing location, we'll strip duplicates
-    values.uniq
-  end
-end
-
-# describes a piece and caches information about its rotations to as to be efficient for iteration
-# ATTRIBUTES:
-#   rotations -- all the rotations of the piece
-#   type -- a numeic "name" of the piece
-#   masks -- an array by location of all legal rotational masks (a n inner array) for that location
-#   placed -- the mask that this piece was last placed at (not a location, but the actual mask used)
-class Piece
-  attr_reader :rotations, :type, :masks
-  attr_accessor :placed
-
-  # transform hashes that change one direction into another when you either flip or rotate a set of directions
-  @@flip_converter = { :west => :west, :east => :east, :nw => :sw, :ne => :se, :sw => :nw, :se => :ne }
-  @@rotate_converter = { :west => :nw, :east => :se, :nw => :ne, :ne => :east, :sw => :west, :se => :sw }
-
-  def initialize( directions, type )
-    @type = type
-    @rotations = Array.new();
-    @map = {}
-
-    generate_rotations( directions )
-    directions.collect! { | value | @@flip_converter[value] }
-    generate_rotations( directions )
-
-    # creates the masks AND a map that returns [location, rotation] for any given mask
-    # this is used when a board is found and we want to draw it, otherwise the map is unused
-    @masks = Array.new();
-    0.upto(59) do | i |
-      even = true
-      @masks[i] = @rotations.collect do | rotation |
-        mask = rotation.start_masks[i]
-        @map[mask[0]] = [ i, rotation ] if (mask)
-        mask || nil
-      end
-      @masks[i].compact!
-    end
-  end
-
-  # rotates a set of directions through all six angles and adds a Rotation to the list for each one
-  def generate_rotations( directions )
-    6.times do
-      rotations.push( Rotation.new(directions))
-      directions.collect! { | value | @@rotate_converter[value] }
-    end
-  end
-
-  # given a board string, adds this piece to the board at whatever location/rotation
-  # important: the outbound board string is 5 wide, the normal location notation is six wide (padded)
-  def fill_string( board_string)
-    location, rotation = @map[@placed]
-    rotation.offsets(location).each do | offset |
-      row, col = offset.divmod(6)
-      board_string[ row*5 + col, 1 ] = @type.to_s
-    end
-  end
-end
-
-# a blank bit board having this form:
-#
-#    0 0 0 0 0 1
-#     0 0 0 0 0 1
-#    0 0 0 0 0 1
-#     0 0 0 0 0 1
-#    0 0 0 0 0 1
-#     0 0 0 0 0 1
-#    0 0 0 0 0 1
-#     0 0 0 0 0 1
-#    0 0 0 0 0 1
-#     0 0 0 0 0 1
-#    1 1 1 1 1 1
-#
-# where left lest significant bit is the top left and the most significant is the lower right
-# the actual board only consists of the 0 places, the 1 places are blockers to keep things from running
-# off the edges or bottom
-def blank_board
-  0b111111100000100000100000100000100000100000100000100000100000100000
-end
-
-def full_board
-  0b111111111111111111111111111111111111111111111111111111111111111111
-end
-
-# determines if a location (bit position) is in an even row
-def is_even( location)
-  (location % 12) < 6
-end
-
-# support function that create three utility maps:
-#  $converter -- for each row an array that maps a five bit row (via array mapping)
-#                to the a five bit representation of the bits below it
-#  $bit_count -- maps a five bit row (via array mapping) to the number of 1s in the row
-#  @@new_regions -- maps a five bit row (via array mapping) to an array of "region" arrays
-#                   a region array has three values the first is a mask of bits in the region,
-#                   the second is the count of those bits and the third is identical to the first
-#                   examples:
-#                           0b10010 => [ 0b01100, 2, 0b01100 ], [ 0b00001, 1, 0b00001]
-#                           0b01010 => [ 0b10000, 1, 0b10000 ], [ 0b00100, 1, 0b00100 ], [ 0b00001, 1, 0b00001]
-#                           0b10001 => [ 0b01110, 3, 0b01110 ]
-def create_collector_support
-  odd_map = [0b11, 0b110, 0b1100, 0b11000, 0b10000]
-  even_map = [0b1, 0b11, 0b110, 0b1100, 0b11000]
-
-  all_odds = Array.new(0b100000)
-  all_evens = Array.new(0b100000)
-  bit_counts = Array.new(0b100000)
-  new_regions = Array.new(0b100000)
-  0.upto(0b11111) do | i |
-    bit_count = odd = even = 0
-    0.upto(4) do | bit |
-      if (i[bit] == 1) then
-        bit_count += 1
-        odd |= odd_map[bit]
-        even |= even_map[bit]
-      end
-    end
-    all_odds[i] = odd
-    all_evens[i] = even
-    bit_counts[i] = bit_count
-    new_regions[i] = create_regions( i)
-  end
-
-  $converter = []
-  10.times { | row | $converter.push((row % 2 == 0) ? all_evens : all_odds) }
-  $bit_counts = bit_counts
-  $regions = new_regions.collect { | set | set.collect { | value | [ value, bit_counts[value], value] } }
-end
-
-# determines if a board is punable, meaning that there is no possibility that it
-# can be filled up with pieces.  A board is prunable if there is a grouping of unfilled spaces
-# that are not a multiple of five.  The following board is an example of a prunable board:
-#    0 0 1 0 0
-#     0 1 0 0 0
-#    1 1 0 0 0
-#     0 1 0 0 0
-#    0 0 0 0 0
-#       ...
-#
-# This board is prunable because the top left corner is only 3 bits in area, no piece will ever fit it
-# parameters:
-#   board -- an initial bit board (6 bit padded rows, see blank_board for format)
-#   location -- starting location, everything above and to the left is already full
-#   slotting -- set to true only when testing initial pieces, when filling normally
-#               additional assumptions are possible
-#
-# Algorithm:
-#    The algorithm starts at the top row (as determined by location) and iterates a row at a time
-#    maintainng counts of active open areas (kept in the collector array) each collector contains
-#    three values at the start of an iteration:
-#          0: mask of bits that would be adjacent to the collector in this row
-#          1: the number of bits collected so far
-#          2: a scratch space starting as zero, but used during the computation to represent
-#             the empty bits in the new row that are adjacent (position 0)
-#  The exact procedure is described in-code
-def prunable( board, location, slotting = false)
-  collectors = []
-  # loop across the rows
-  (location / 6).to_i.upto(9) do | row_on |
-    # obtain a set of regions representing the bits of the current row.
-    regions = $regions[(board >> (row_on * 6)) & 0b11111]
-    converter = $converter[row_on]
-
-    # track the number of collectors at the start of the cycle so that
-    # we don't compute against newly created collectors, only existing collectors
-    initial_collector_count = collectors.length
-
-    # loop against the regions.  For each region of the row
-    # we will see if it connects to one or more existing collectors.
-    # if it connects to 1 collector, the bits from the region are added to the
-    # bits of the collector and the mask is placed in collector[2]
-    # If the region overlaps more than one collector then all the collectors
-    # it overlaps with are merged into the first one (the others are set to nil in the array)
-    # if NO collectors are found then the region is copied as a new collector
-    regions.each do | region |
-      collector_found = nil
-      region_mask = region[2]
-      initial_collector_count.times do | collector_num |
-        collector = collectors[collector_num]
-        if (collector) then
-          collector_mask = collector[0]
-          if (collector_mask & region_mask != 0) then
-            if (collector_found) then
-              collector_found[0] |= collector_mask
-              collector_found[1] += collector[1]
-              collector_found[2] |= collector[2]
-              collectors[collector_num] = nil
-            else
-              collector_found = collector
-              collector[1] += region[1]
-              collector[2] |= region_mask
-            end
-          end
-        end
-      end
-      if (collector_found == nil) then
-        collectors.push(Array.new(region))
-      end
-    end
-
-    # check the existing collectors, if any collector overlapped no bits in the region its [2] value will
-    # be zero.  The size of any such reaason is tested if it is not a multiple of five true is returned since
-    # the board is prunable.  if it is a multiple of five it is removed.
-    # Collector that are still active have a new adjacent value [0] set based n the matched bits
-    # and have [2] cleared out for the next cycle.
-    collectors.length.times do | collector_num |
-      collector = collectors[collector_num]
-      if (collector) then
-        if (collector[2] == 0) then
-          return true if (collector[1] % 5 != 0)
-          collectors[collector_num] = nil
-        else
-          # if a collector matches all bits in the row then we can return unprunable early for the
-          # following reasons:
-          #    1) there can be no more unavailable bits bince we fill from the top left downward
-          #    2) all previous regions have been closed or joined so only this region can fail
-          #    3) this region must be good since there can never be only 1 region that is nuot
-          #       a multiple of five
-          # this rule only applies when filling normally, so we ignore the rule if we are "slotting"
-          # in pieces to see what configurations work for them (the only other time this algorithm is used).
-          return false if (collector[2] == 0b11111 && !slotting)
-          collector[0] = converter[collector[2]]
-          collector[2] = 0
-        end
-      end
-    end
-
-    # get rid of all the empty converters for the next round
-    collectors.compact!
-  end
-  return false if (collectors.length <= 1) # 1 collector or less and the region is fine
-  collectors.any? { | collector | (collector[1] % 5) != 0 } # more than 1 and we test them all for bad size
-end
-
-# creates a region given a row mask.  see prunable for what a "region" is
-def create_regions( value )
-  regions = []
-  cur_region = 0
-  5.times do | bit |
-    if (value[bit] == 0) then
-      cur_region |= 1 << bit
-    else
-      if (cur_region != 0 ) then
-        regions.push( cur_region)
-        cur_region = 0;
-      end
-    end
-  end
-  regions.push(cur_region) if (cur_region != 0)
-  regions
-end
-
-# find up to the counted number of solutions (or all solutions) and prints the final result
-def find_all
-  find_top( 1)
-  find_top( 0)
-  print_results
-end
-
-# show the board
-def print_results
-  print "#{@boards_found} solutions found\n\n"
-  print_full_board( @min_board)
-  print "\n"
-  print_full_board( @max_board)
-  print "\n"
-end
-
-# finds solutions.  This special version of the main function is only used for the top level
-# the reason for it is basically to force a particular ordering on how the rotations are tested for
-# the first piece.  It is called twice, first looking for placements of the odd rotations and then
-# looking for placements of the even locations.
-#
-# WHY?
-#   Since any found solution has an inverse we want to maximize finding solutions that are not already found
-#   as an inverse.  The inverse will ALWAYS be 3 one of the piece configurations that is exactly 3 rotations away
-#   (an odd number).  Checking even vs odd then produces a higher probability of finding more pieces earlier
-#   in the cycle.  We still need to keep checking all the permutations, but our probability of finding one will
-#   diminsh over time.  Since we are TOLD how many to search for this lets us exit before checking all pieces
-#   this bennifit is very great when seeking small numbers of solutions and is 0 when looking for more than the
-#   maximum number
-def find_top( rotation_skip)
-  board = blank_board
-  (@pieces.length-1).times do
-    piece = @pieces.shift
-    piece.masks[0].each do | mask, imask, cmask |
-      if ((rotation_skip += 1) % 2 == 0) then
-        piece.placed = mask
-        find( 1, 1, board | mask)
-      end
-    end
-    @pieces.push(piece)
-  end
-  piece = @pieces.shift
-  @pieces.push(piece)
-end
-
-# the normail find routine, iterates through the available pieces, checks all rotations at the current location
-# and adds any boards found.  depth is achieved via recursion.  the overall approach is described
-# here: http://www-128.ibm.com/developerworks/java/library/j-javaopt/
-# parameters:
-#  start_location -- where to start looking for place for the next piece at
-#  placed -- number of pieces placed
-#  board -- current state of the board
-#
-# see in-code comments
-def find( start_location, placed, board)
-  # find the next location to place a piece by looking for an empty bit
-  while board[start_location] == 1
-    start_location += 1
-  end
-
-  @pieces.length.times do
-    piece = @pieces.shift
-    piece.masks[start_location].each do | mask, imask, cmask |
-      if ( board & cmask == imask) then
-        piece.placed = mask
-        if (placed == 9) then
-          add_board
-        else
-          find( start_location + 1, placed + 1, board | mask)
-        end
-      end
-    end
-    @pieces.push(piece)
-  end
-end
-
-# print the board
-def print_full_board( board_string)
-  10.times do | row |
-    print " " if (row % 2 == 1)
-    5.times do | col |
-      print "#{board_string[row*5 + col,1]} "
-    end
-    print "\n"
-  end
-end
-
-# when a board is found we "draw it" into a string and then flip that string, adding both to
-# the list (hash) of solutions if they are unique.
-def add_board
-  board_string = "99999999999999999999999999999999999999999999999999"
-  @all_pieces.each {  | piece | piece.fill_string( board_string ) }
-  save( board_string)
-  save( board_string.reverse)
-end
-
-# adds a board string to the list (if new) and updates the current best/worst board
-def save( board_string)
-  if (@all_boards[board_string] == nil) then
-    @min_board = board_string if (board_string < @min_board)
-    @max_board = board_string if (board_string > @max_board)
-    @all_boards.store(board_string,true)
-    @boards_found += 1
-
-    # the exit motif is a time saver.  Ideally the function should return, but those tests
-    # take noticeable time (performance).
-    if (@boards_found == @stop_count) then
-      print_results
-      exit(0)
-    end
-  end
-end
-
-
-##
-## MAIN BODY :)
-##
-create_collector_support
-@pieces = [
-  Piece.new( [ :nw, :ne, :east, :east ], 2),
-  Piece.new( [ :ne, :se, :east, :ne ], 7),
-  Piece.new( [ :ne, :east, :ne, :nw ], 1),
-  Piece.new( [ :east, :sw, :sw, :se ], 6),
-  Piece.new( [ :east, :ne, :se, :ne ], 5),
-  Piece.new( [ :east, :east, :east, :se ], 0),
-  Piece.new( [ :ne, :nw, :se, :east, :se ], 4),
-  Piece.new( [ :se, :se, :se, :west ], 9),
-  Piece.new( [ :se, :se, :east, :se ], 8),
-  Piece.new( [ :east, :east, :sw, :se ], 3)
-  ];
-
-@all_pieces = Array.new( @pieces)
-
-@min_board = "99999999999999999999999999999999999999999999999999"
-@max_board = "00000000000000000000000000000000000000000000000000"
-@stop_count = ARGV[0].to_i || 2089
-@all_boards = {}
-@boards_found = 0
-
-find_all ######## DO IT!!!
diff --git a/benchmark/bm_so_nbody.rb b/benchmark/bm_so_nbody.rb
deleted file mode 100644
index d6c5bb9e61..0000000000
--- a/benchmark/bm_so_nbody.rb
+++ /dev/null
@@ -1,148 +0,0 @@
-# The Computer Language Shootout
-# http://shootout.alioth.debian.org
-#
-# Optimized for Ruby by Jesse Millikan
-# From version ported by Michael Neumann from the C gcc version,
-# which was written by Christoph Bauer.
-
-SOLAR_MASS = 4 * Math::PI**2
-DAYS_PER_YEAR = 365.24
-
-def _puts *args
-end
-
-class Planet
- attr_accessor :x, :y, :z, :vx, :vy, :vz, :mass
-
- def initialize(x, y, z, vx, vy, vz, mass)
-  @x, @y, @z = x, y, z
-  @vx, @vy, @vz = vx * DAYS_PER_YEAR, vy * DAYS_PER_YEAR, vz * DAYS_PER_YEAR
-  @mass = mass * SOLAR_MASS
- end
-
- def move_from_i(bodies, nbodies, dt, i)
-  while i < nbodies
-   b2 = bodies[i]
-   dx = @x - b2.x
-   dy = @y - b2.y
-   dz = @z - b2.z
-
-   distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
-   mag = dt / (distance * distance * distance)
-   b_mass_mag, b2_mass_mag = @mass * mag, b2.mass * mag
-
-   @vx -= dx * b2_mass_mag
-   @vy -= dy * b2_mass_mag
-   @vz -= dz * b2_mass_mag
-   b2.vx += dx * b_mass_mag
-   b2.vy += dy * b_mass_mag
-   b2.vz += dz * b_mass_mag
-   i += 1
-  end
-
-  @x += dt * @vx
-  @y += dt * @vy
-  @z += dt * @vz
- end
-end
-
-def energy(bodies)
-  e = 0.0
-  nbodies = bodies.size
-
-  for i in 0 ... nbodies
-    b = bodies[i]
-    e += 0.5 * b.mass * (b.vx * b.vx + b.vy * b.vy + b.vz * b.vz)
-    for j in (i + 1) ... nbodies
-      b2 = bodies[j]
-      dx = b.x - b2.x
-      dy = b.y - b2.y
-      dz = b.z - b2.z
-      distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
-      e -= (b.mass * b2.mass) / distance
-    end
-  end
-  e
-end
-
-def offset_momentum(bodies)
-  px, py, pz = 0.0, 0.0, 0.0
-
-  for b in bodies
-    m = b.mass
-    px += b.vx * m
-    py += b.vy * m
-    pz += b.vz * m
-  end
-
-  b = bodies[0]
-  b.vx = - px / SOLAR_MASS
-  b.vy = - py / SOLAR_MASS
-  b.vz = - pz / SOLAR_MASS
-end
-
-BODIES = [
-  # sun
-  Planet.new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
-
-  # jupiter
-  Planet.new(
-    4.84143144246472090e+00,
-    -1.16032004402742839e+00,
-    -1.03622044471123109e-01,
-    1.66007664274403694e-03,
-    7.69901118419740425e-03,
-    -6.90460016972063023e-05,
-    9.54791938424326609e-04),
-
-  # saturn
-  Planet.new(
-    8.34336671824457987e+00,
-    4.12479856412430479e+00,
-    -4.03523417114321381e-01,
-    -2.76742510726862411e-03,
-    4.99852801234917238e-03,
-    2.30417297573763929e-05,
-    2.85885980666130812e-04),
-
-  # uranus
-  Planet.new(
-    1.28943695621391310e+01,
-    -1.51111514016986312e+01,
-    -2.23307578892655734e-01,
-    2.96460137564761618e-03,
-    2.37847173959480950e-03,
-    -2.96589568540237556e-05,
-    4.36624404335156298e-05),
-
-  # neptune
-  Planet.new(
-    1.53796971148509165e+01,
-    -2.59193146099879641e+01,
-    1.79258772950371181e-01,
-    2.68067772490389322e-03,
-    1.62824170038242295e-03,
-    -9.51592254519715870e-05,
-    5.15138902046611451e-05)
-]
-
-init = 200_000 # ARGV[0]
-n = Integer(init)
-
-offset_momentum(BODIES)
-
-puts "%.9f" % energy(BODIES)
-
-nbodies = BODIES.size
-dt = 0.01
-
-n.times do
-  i = 0
-  while i < nbodies
-    b = BODIES[i]
-    b.move_from_i(BODIES, nbodies, dt, i + 1)
-    i += 1
-  end
-end
-
-puts "%.9f" % energy(BODIES)
diff --git a/benchmark/bm_so_nested_loop.rb b/benchmark/bm_so_nested_loop.rb
deleted file mode 100644
index a0513f8c47..0000000000
--- a/benchmark/bm_so_nested_loop.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/usr/bin/ruby
-# -*- mode: ruby -*-
-# $Id: nestedloop-ruby.code,v 1.4 2004/11/13 07:42:22 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-# from Avi Bryant
-
-n = 16 # Integer(ARGV.shift || 1)
-x = 0
-n.times do
-    n.times do
-        n.times do
-            n.times do
-                n.times do
-                    n.times do
-                        x += 1
-                    end
-                end
-            end
-        end
-    end
-end
-# puts x
-
-
diff --git a/benchmark/bm_so_nsieve.rb b/benchmark/bm_so_nsieve.rb
deleted file mode 100644
index a65cc78233..0000000000
--- a/benchmark/bm_so_nsieve.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# The Computer Language Shootout
-# http://shootout.alioth.debian.org/
-#
-# contributed by Glenn Parker, March 2005
-# modified by Evan Phoenix, Sept 2006
-
-def sieve(m)
-  flags = Flags.dup[0,m]
-  count = 0
-  pmax = m - 1
-  p = 2
-  while p <= pmax
-    unless flags[p].zero?
-      count += 1
-      mult = p
-      while mult <= pmax
-        flags[mult] = 0
-        mult += p
-      end
-    end
-    p += 1
-  end
-  count
-end
-
-n = 9 # (ARGV[0] || 2).to_i
-Flags = ("\x1" * ( 2 ** n * 10_000)).unpack("c*")
-
-n.downto(n-2) do |exponent|
-  break if exponent < 0
-  m = (1 << exponent) * 10_000
-  # m = (2 ** exponent) * 10_000
-  count = sieve(m)
-  printf "Primes up to %8d %8d\n", m, count
-end
diff --git a/benchmark/bm_so_nsieve_bits.rb b/benchmark/bm_so_nsieve_bits.rb
deleted file mode 100644
index 6f958ee44e..0000000000
--- a/benchmark/bm_so_nsieve_bits.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/usr/bin/ruby
-#coding: us-ascii
-#
-# The Great Computer Language Shootout
-# http://shootout.alioth.debian.org/
-#
-# nsieve-bits in Ruby
-# Contributed by Glenn Parker, March 2005
-
-CharExponent = 3
-BitsPerChar = 1 << CharExponent
-LowMask = BitsPerChar - 1
-
-def sieve(m)
-  items = "\xFF" * ((m / BitsPerChar) + 1)
-  masks = ""
-  BitsPerChar.times do |b|
-    masks << (1 << b).chr
-  end
-
-  count = 0
-  pmax = m - 1
-  2.step(pmax, 1) do |p|
-    if items[p >> CharExponent][p & LowMask] == 1
-      count += 1
-      p.step(pmax, p) do |mult|
-	a = mult >> CharExponent
-	b = mult & LowMask
-	items[a] -= masks[b] if items[a][b] != 0
-      end
-    end
-  end
-  count
-end
-
-n = 9 # (ARGV[0] || 2).to_i
-n.step(n - 2, -1) do |exponent|
-  break if exponent < 0
-  m = 2 ** exponent * 10_000
-  count = sieve(m)
-  printf "Primes up to %8d %8d\n", m, count
-end
-
diff --git a/benchmark/bm_so_object.rb b/benchmark/bm_so_object.rb
deleted file mode 100644
index e8607c7199..0000000000
--- a/benchmark/bm_so_object.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-#!/usr/bin/ruby
-# -*- mode: ruby -*-
-# $Id: objinst-ruby.code,v 1.4 2004/11/13 07:42:25 bfulgham Exp $
-# http://www.bagley.org/~doug/shootout/
-# with help from Aristarkh Zagorodnikov
-
-class Toggle
-    def initialize(start_state)
-        @bool = start_state
-    end
-
-    def value
-        @bool
-    end
-
-    def activate
-        @bool = !@bool
-        self
-    end
-end
-
-class NthToggle < Toggle
-    def initialize(start_state, max_counter)
-        super start_state
-        @count_max = max_counter
-        @counter = 0
-    end
-
-    def activate
-        @counter += 1
-        if @counter >= @count_max
-            @bool = !@bool
-            @counter = 0
-        end
-        self
-    end
-end
-
-n = 1500000 # (ARGV.shift || 1).to_i
-
-toggle = Toggle.new 1
-5.times do
-    toggle.activate.value ? 'true' : 'false'
-end
-n.times do
-    toggle = Toggle.new 1
-end
-
-ntoggle = NthToggle.new 1, 3
-8.times do
-    ntoggle.activate.value ? 'true' : 'false'
-end
-n.times do
-    ntoggle = NthToggle.new 1, 3
-end
-
diff --git a/benchmark/bm_so_partial_sums.rb b/benchmark/bm_so_partial_sums.rb
deleted file mode 100644
index 630b45cb8d..0000000000
--- a/benchmark/bm_so_partial_sums.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-n = 2_500_000 # (ARGV.shift || 1).to_i
-
-alt = 1.0 ; s0 = s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = 0.0
-
-1.upto(n) do |d|
-  d = d.to_f ; d2 = d * d ; d3 = d2 * d ; ds = Math.sin(d) ; dc = Math.cos(d)
-
-  s0 += (2.0 / 3.0) ** (d - 1.0)
-  s1 += 1.0 / Math.sqrt(d)
-  s2 += 1.0 / (d * (d + 1.0))
-  s3 += 1.0 / (d3 * ds * ds)
-  s4 += 1.0 / (d3 * dc * dc)
-  s5 += 1.0 / d
-  s6 += 1.0 / d2
-  s7 += alt / d
-  s8 += alt / (2.0 * d - 1.0)
-
-  alt = -alt
-end
-
-if false
-  printf("%.9f\t(2/3)^k\n", s0)
-  printf("%.9f\tk^-0.5\n", s1)
-  printf("%.9f\t1/k(k+1)\n", s2)
-  printf("%.9f\tFlint Hills\n", s3)
-  printf("%.9f\tCookson Hills\n", s4)
-  printf("%.9f\tHarmonic\n", s5)
-  printf("%.9f\tRiemann Zeta\n", s6)
-  printf("%.9f\tAlternating Harmonic\n", s7)
-  printf("%.9f\tGregory\n", s8)
-end
diff --git a/benchmark/bm_so_pidigits.rb b/benchmark/bm_so_pidigits.rb
deleted file mode 100644
index 9a537b2d1c..0000000000
--- a/benchmark/bm_so_pidigits.rb
+++ /dev/null
@@ -1,92 +0,0 @@
-# The Great Computer Language Shootout
-# http://shootout.alioth.debian.org/
-#
-# contributed by Gabriele Renzi
-
-class PiDigitSpigot
-
-    def initialize()
-        @z = Transformation.new 1,0,0,1
-        @x = Transformation.new 0,0,0,0
-        @inverse = Transformation.new 0,0,0,0
-    end
-
-    def next!
-        @y = @z.extract(3)
-        if safe? @y
-            @z = produce(@y)
-            @y
-        else
-            @z = consume @x.next!()
-            next!()
-        end
-    end
-
-    def safe?(digit)
-        digit == @z.extract(4)
-    end
-
-    def produce(i)
-        @inverse.qrst(10,-10*i,0,1).compose(@z)
-    end
-
-    def consume(a)
-        @z.compose(a)
-    end
-end
-
-
-class Transformation
-    attr_reader :q, :r, :s, :t
-    def initialize(q, r, s, t)
-        @q,@r,@s,@t,@k = q,r,s,t,0
-    end
-
-    def next!()
-        @q = @k = @k + 1
-        @r = 4 * @k + 2
-        @s = 0
-        @t = 2 * @k + 1
-        self
-    end
-
-    def extract(j)
-        (@q * j + @r) / (@s * j + @t)
-    end
-
-    def compose(a)
-        self.class.new( @q * a.q,
-                        @q * a.r + r * a.t,
-                        @s * a.q + t * a.s,
-                        @s * a.r + t * a.t
-                    )
-    end
-
-    def qrst *args
-        initialize *args
-        self
-    end
-
-
-end
-
-
-WIDTH = 10
-n = 2_500 # Integer(ARGV[0])
-j = 0
-
-digits = PiDigitSpigot.new
-
-while n > 0
-    if n >= WIDTH
-        WIDTH.times {print digits.next!}
-        j += WIDTH
-    else
-        n.times {print digits.next!}
-        (WIDTH-n).times {print " "}
-        j += n
-    end
-    puts "\t:"+j.to_s
-    n -= WIDTH
-end
-
diff --git a/benchmark/bm_so_random.rb b/benchmark/bm_so_random.rb
deleted file mode 100644
index a66b9e8e63..0000000000
--- a/benchmark/bm_so_random.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# from http://www.bagley.org/~doug/shootout/bench/random/random.ruby
-
-IM = 139968.0
-IA = 3877.0
-IC = 29573.0
-
-$last = 42.0
-
-def gen_random(max)
-  (max * ($last = ($last * IA + IC) % IM)) / IM
-end
-
-N = 3_000_000
-
-i = 0
-while i<N
-  i +=1
-  gen_random(100.0)
-end
-# "%.9f" % gen_random(100.0)
diff --git a/benchmark/bm_so_sieve.rb b/benchmark/bm_so_sieve.rb
deleted file mode 100644
index 43dc302648..0000000000
--- a/benchmark/bm_so_sieve.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-# from http://www.bagley.org/~doug/shootout/bench/sieve/sieve.ruby
-num = 500
-count = i = j = 0
-flags0 = Array.new(8192,1)
-k = 0
-while k < num
-  k += 1
-  count = 0
-  flags = flags0.dup
-  i = 2
-  while i<8192
-    i += 1
-    if flags[i]
-      # remove all multiples of prime: i
-      j = i*i
-      while j < 8192
-        j += i
-        flags[j] = nil
-      end
-      count += 1
-    end
-  end
-end
-count
diff --git a/benchmark/bm_so_spectralnorm.rb b/benchmark/bm_so_spectralnorm.rb
deleted file mode 100644
index 6b97206689..0000000000
--- a/benchmark/bm_so_spectralnorm.rb
+++ /dev/null
@@ -1,50 +0,0 @@
-# The Computer Language Shootout
-# http://shootout.alioth.debian.org/
-# Contributed by Sokolov Yura
-
-def eval_A(i,j)
-	return 1.0/((i+j)*(i+j+1)/2+i+1)
-end
-
-def eval_A_times_u(u)
-        v, i = nil, nil
-	(0..u.length-1).collect { |i|
-                v = 0
-		for j in 0..u.length-1
-			v += eval_A(i,j)*u[j]
-                end
-                v
-        }
-end
-
-def eval_At_times_u(u)
-	v, i = nil, nil
-	(0..u.length-1).collect{|i|
-                v = 0
-		for j in 0..u.length-1
-			v += eval_A(j,i)*u[j]
-                end
-                v
-        }
-end
-
-def eval_AtA_times_u(u)
-	return eval_At_times_u(eval_A_times_u(u))
-end
-
-n = 500 # ARGV[0].to_i
-
-u=[1]*n
-for i in 1..10
-        v=eval_AtA_times_u(u)
-        u=eval_AtA_times_u(v)
-end
-vBv=0
-vv=0
-for i in 0..n-1
-        vBv += u[i]*v[i]
-        vv += v[i]*v[i]
-end
-
-str = "%0.9f" % (Math.sqrt(vBv/vv)), "\n"
-# print str
diff --git a/benchmark/bm_string_index.rb b/benchmark/bm_string_index.rb
deleted file mode 100644
index 7783111082..0000000000
--- a/benchmark/bm_string_index.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-str1 = "あ" * 1024 + "い" # not single byte optimizable
-str2 = "い"
-100_000.times { str1.index(str2) }
diff --git a/benchmark/bm_string_scan_re.rb b/benchmark/bm_string_scan_re.rb
deleted file mode 100644
index b0d60201a9..0000000000
--- a/benchmark/bm_string_scan_re.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-str = Array.new(1_000, 'abc').join(',')
-1_000.times { str.scan(/abc/) }
diff --git a/benchmark/bm_string_scan_str.rb b/benchmark/bm_string_scan_str.rb
deleted file mode 100644
index 42440bd948..0000000000
--- a/benchmark/bm_string_scan_str.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-str = Array.new(1_000, 'abc').join(',')
-1_000.times { str.scan('abc') }
diff --git a/benchmark/bm_time_subsec.rb b/benchmark/bm_time_subsec.rb
deleted file mode 100644
index 505021c701..0000000000
--- a/benchmark/bm_time_subsec.rb
+++ /dev/null
@@ -1,2 +0,0 @@
-t = Time.now
-4000000.times { t.subsec }
diff --git a/benchmark/bm_vm3_backtrace.rb b/benchmark/bm_vm3_backtrace.rb
deleted file mode 100644
index 0fbf73e1ca..0000000000
--- a/benchmark/bm_vm3_backtrace.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-# get last backtrace
-
-begin
-  caller(0, 0)
-rescue ArgumentError
-  alias caller_orig caller
-  def caller lev, n
-    caller_orig(lev)[0..n]
-  end
-end
-
-def rec n
-  if n < 0
-    100_000.times{
-      caller(0, 1)
-    }
-  else
-    rec(n-1)
-  end
-end
-
-rec 50
diff --git a/benchmark/bm_vm3_clearmethodcache.rb b/benchmark/bm_vm3_clearmethodcache.rb
deleted file mode 100644
index 9661323cd2..0000000000
--- a/benchmark/bm_vm3_clearmethodcache.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-i = 0
-while i<200_000
-  i += 1
-
-  Class.new{
-    def m; end
-  }
-end
diff --git a/benchmark/bm_vm3_gc.rb b/benchmark/bm_vm3_gc.rb
deleted file mode 100644
index e668026915..0000000000
--- a/benchmark/bm_vm3_gc.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-5000.times do
-  100.times do
-    {"xxxx"=>"yyyy"}
-  end
-  GC.start
-end
diff --git a/benchmark/bm_vm3_gc_old_full.rb b/benchmark/bm_vm3_gc_old_full.rb
deleted file mode 100644
index cfdfc8c5a5..0000000000
--- a/benchmark/bm_vm3_gc_old_full.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-old_object = Array.new(1_000_000){''}
-100.times do
-  GC.start
-end
diff --git a/benchmark/bm_vm3_gc_old_immediate.rb b/benchmark/bm_vm3_gc_old_immediate.rb
deleted file mode 100644
index ad22feb655..0000000000
--- a/benchmark/bm_vm3_gc_old_immediate.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-old_object = Array.new(1_000_000){''}
-30_000.times do
-  GC.start(full_mark: false, immediate_sweep: true)
-end
diff --git a/benchmark/bm_vm3_gc_old_lazy.rb b/benchmark/bm_vm3_gc_old_lazy.rb
deleted file mode 100644
index b74d44baf1..0000000000
--- a/benchmark/bm_vm3_gc_old_lazy.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-old_object = Array.new(1_000_000){''}
-30_000.times do
-  GC.start(full_mark: false, immediate_sweep: false)
-end
diff --git a/benchmark/bm_vm_symbol_block_pass.rb b/benchmark/bm_vm_symbol_block_pass.rb
deleted file mode 100644
index 1d433353e1..0000000000
--- a/benchmark/bm_vm_symbol_block_pass.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-class C
-  1000.times {|i|
-    eval("def i#{i};end")
-  }
-end
-
-c = C.new
-m = C.instance_methods(false)
-5_000.times do
-  m.each do |n|
-    c.tap(&n)
-  end
-end
diff --git a/benchmark/bm_vm_thread_alive_check1.rb b/benchmark/bm_vm_thread_alive_check1.rb
deleted file mode 100644
index c993accdda..0000000000
--- a/benchmark/bm_vm_thread_alive_check1.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-5_000.times{
-  t = Thread.new{}
-  while t.alive?
-    Thread.pass
-  end
-}
diff --git a/benchmark/bm_vm_thread_close.rb b/benchmark/bm_vm_thread_close.rb
deleted file mode 100644
index 3e9a265ce8..0000000000
--- a/benchmark/bm_vm_thread_close.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-1000.times { Thread.new { sleep } }
-i = 0
-while i<100_000 # benchmark loop 3
-  i += 1
-  IO.pipe.each(&:close)
-end
diff --git a/benchmark/bm_vm_thread_condvar1.rb b/benchmark/bm_vm_thread_condvar1.rb
deleted file mode 100644
index cf5706b23e..0000000000
--- a/benchmark/bm_vm_thread_condvar1.rb
+++ /dev/null
@@ -1,28 +0,0 @@
-# two threads, two mutex, two condvar ping-pong
-require 'thread'
-m1 = Mutex.new
-m2 = Mutex.new
-cv1 = ConditionVariable.new
-cv2 = ConditionVariable.new
-max = 100000
-i = 0
-wait = nil
-m2.synchronize do
-  wait = Thread.new do
-    m1.synchronize do
-      m2.synchronize { cv2.signal }
-      while (i += 1) < max
-        cv1.wait(m1)
-        cv2.signal
-      end
-    end
-  end
-  cv2.wait(m2)
-end
-m1.synchronize do
-  while i < max
-    cv1.signal
-    cv2.wait(m1)
-  end
-end
-wait.join
diff --git a/benchmark/bm_vm_thread_condvar2.rb b/benchmark/bm_vm_thread_condvar2.rb
deleted file mode 100644
index 7c8dc19481..0000000000
--- a/benchmark/bm_vm_thread_condvar2.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-# many threads, one mutex, many condvars
-require 'thread'
-m = Mutex.new
-cv1 = ConditionVariable.new
-cv2 = ConditionVariable.new
-max = 1000
-n = 100
-waiting = 0
-scvs = []
-waiters = n.times.map do |i|
-  start_cv = ConditionVariable.new
-  scvs << start_cv
-  start_mtx = Mutex.new
-  start_mtx.synchronize do
-    th = Thread.new(start_mtx, start_cv) do |sm, scv|
-      m.synchronize do
-        sm.synchronize { scv.signal }
-        max.times do
-          cv2.signal if (waiting += 1) == n
-          cv1.wait(m)
-        end
-      end
-    end
-    start_cv.wait(start_mtx)
-    th
-  end
-end
-m.synchronize do
-  max.times do
-    cv2.wait(m) until waiting == n
-    waiting = 0
-    cv1.broadcast
-  end
-end
-waiters.each(&:join)
diff --git a/benchmark/bm_vm_thread_create_join.rb b/benchmark/bm_vm_thread_create_join.rb
deleted file mode 100644
index 393cd45df9..0000000000
--- a/benchmark/bm_vm_thread_create_join.rb
+++ /dev/null
@@ -1,6 +0,0 @@
-i = 0
-while i<100_000 # benchmark loop 3
-  i += 1
-  Thread.new{
-  }.join
-end
diff --git a/benchmark/bm_vm_thread_mutex1.rb b/benchmark/bm_vm_thread_mutex1.rb
deleted file mode 100644
index 66e42c85e1..0000000000
--- a/benchmark/bm_vm_thread_mutex1.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# one thread, one mutex (no contention)
-
-require 'thread'
-m = Thread::Mutex.new
-r = 0
-max = 2000
-lmax = max * max
-(1..1).map{
-  Thread.new{
-    i = 0
-    while i<lmax
-      i += 1
-      m.synchronize{
-        r += 1
-      }
-    end
-  }
-}.each{|e|
-  e.join
-}
-raise r.to_s if r != max * max
diff --git a/benchmark/bm_vm_thread_mutex2.rb b/benchmark/bm_vm_thread_mutex2.rb
deleted file mode 100644
index 6e6c804c31..0000000000
--- a/benchmark/bm_vm_thread_mutex2.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# two threads, one mutex
-
-require 'thread'
-m = Thread::Mutex.new
-r = 0
-max = 2000
-lmax = (max * max)/2
-(1..2).map{
-  Thread.new{
-    i = 0
-    while i<lmax
-      i += 1
-      m.synchronize{
-        r += 1
-      }
-    end
-  }
-}.each{|e|
-  e.join
-}
-raise r.to_s if r != max * max
diff --git a/benchmark/bm_vm_thread_mutex3.rb b/benchmark/bm_vm_thread_mutex3.rb
deleted file mode 100644
index c750dc542a..0000000000
--- a/benchmark/bm_vm_thread_mutex3.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# 1000 threads, one mutex
-
-require 'thread'
-m = Thread::Mutex.new
-r = 0
-max = 2000
-(1..max).map{
-  Thread.new{
-    i = 0
-    while i<max
-      i += 1
-      m.synchronize{
-        r += 1
-      }
-    end
-  }
-}.each{|e|
-  e.join
-}
-raise r.to_s if r != max * max
diff --git a/benchmark/bm_vm_thread_pass.rb b/benchmark/bm_vm_thread_pass.rb
deleted file mode 100644
index b5b3c0bc85..0000000000
--- a/benchmark/bm_vm_thread_pass.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# Plenty Thtread.pass
-# A performance may depend on GVL implementation.
-
-tmax = (ARGV.shift || 2).to_i
-lmax = 200_000 / tmax
-
-(1..tmax).map{
-  Thread.new{
-    lmax.times{
-      Thread.pass
-    }
-  }
-}.each{|t| t.join}
-
-
diff --git a/benchmark/bm_vm_thread_pass_flood.rb b/benchmark/bm_vm_thread_pass_flood.rb
deleted file mode 100644
index a660aafc18..0000000000
--- a/benchmark/bm_vm_thread_pass_flood.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# n.b. this is a good test for GVL when pinned to a single CPU
-
-1000.times{
-  Thread.new{loop{Thread.pass}}
-}
-
-i = 0
-while i<10000
-  i += 1
-end
diff --git a/benchmark/bm_vm_thread_pipe.rb b/benchmark/bm_vm_thread_pipe.rb
deleted file mode 100644
index 112a621905..0000000000
--- a/benchmark/bm_vm_thread_pipe.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# Measure small and plenty pipe read/write.
-# A performance may depend on GVL implementation.
-
-lmax = 100_000
-r, w = IO.pipe
-[Thread.new{
-  lmax.times{
-    w.write('a')
-  }
-  p "w:exit"
-}, Thread.new{
-  lmax.times{
-    r.read(1)
-  }
-  p "r:exit"
-}].each{|t| t.join}
-
diff --git a/benchmark/bm_vm_thread_queue.rb b/benchmark/bm_vm_thread_queue.rb
deleted file mode 100644
index 274ceda366..0000000000
--- a/benchmark/bm_vm_thread_queue.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-require 'thread'
-
-n = 1_000_000
-q = Thread::Queue.new
-consumer = Thread.new{
-  while q.pop
-    # consuming
-  end
-}
-
-producer = Thread.new{
-  n.times{
-    q.push true
-  }
-  q.push nil
-}
-
-consumer.join
diff --git a/benchmark/bm_vm_thread_sized_queue.rb b/benchmark/bm_vm_thread_sized_queue.rb
deleted file mode 100644
index 7b9af5482b..0000000000
--- a/benchmark/bm_vm_thread_sized_queue.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-require 'thread'
-# on producer, one consumer
-
-n = 1_000_000
-q = Thread::SizedQueue.new(100)
-consumer = Thread.new{
-  while q.pop
-    # consuming
-  end
-}
-
-producer = Thread.new{
-  while n > 0
-    q.push true
-    n -= 1
-  end
-  q.push nil
-}
-
-consumer.join
diff --git a/benchmark/bm_vm_thread_sized_queue2.rb b/benchmark/bm_vm_thread_sized_queue2.rb
deleted file mode 100644
index de9f55e978..0000000000
--- a/benchmark/bm_vm_thread_sized_queue2.rb
+++ /dev/null
@@ -1,23 +0,0 @@
-require 'thread'
-# one producer, many consumers
-n = 1_000_000
-m = 10
-q = Thread::SizedQueue.new(100)
-consumers = m.times.map do
-  Thread.new do
-    while q.pop
-      # consuming
-    end
-  end
-end
-
-producer = Thread.new do
-  while n > 0
-    q.push true
-    n -= 1
-  end
-  m.times { q.push nil }
-end
-
-producer.join
-consumers.each(&:join)
diff --git a/benchmark/bm_vm_thread_sized_queue3.rb b/benchmark/bm_vm_thread_sized_queue3.rb
deleted file mode 100644
index ce5f1796d8..0000000000
--- a/benchmark/bm_vm_thread_sized_queue3.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-require 'thread'
-# many producers, one consumer
-n = 1_000_000
-m = 10
-q = Thread::SizedQueue.new(100)
-consumer = Thread.new do
-  while q.pop
-    # consuming
-  end
-end
-
-producers = m.times.map do
-  Thread.new do
-    while n > 0
-      q.push true
-      n -= 1
-    end
-  end
-end
-producers.each(&:join)
-q.push nil
-consumer.join
diff --git a/benchmark/bm_vm_thread_sized_queue4.rb b/benchmark/bm_vm_thread_sized_queue4.rb
deleted file mode 100644
index a9b7d80ec0..0000000000
--- a/benchmark/bm_vm_thread_sized_queue4.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-require 'thread'
-# many producers, many consumers
-nr = 1_000_000
-n = 10
-m = 10
-q = Thread::SizedQueue.new(100)
-consumers = n.times.map do
-  Thread.new do
-    while q.pop
-      # consuming
-    end
-  end
-end
-
-producers = m.times.map do
-  Thread.new do
-    while nr > 0
-      q.push true
-      nr -= 1
-    end
-  end
-end
-
-producers.each(&:join)
-n.times { q.push nil }
-consumers.each(&:join)
diff --git a/benchmark/dir_empty_p.yml b/benchmark/dir_empty_p.yml
new file mode 100644
index 0000000000..73e59bec98
--- /dev/null
+++ b/benchmark/dir_empty_p.yml
@@ -0,0 +1,8 @@
+benchmark:
+  dir_empty_p: |
+    require 'tmpdir'
+    max = 100_000
+    Dir.mktmpdir('bm_dir_empty_p') do |dir|
+      max.times { Dir.empty?(dir) }
+    end
+loop_count: 1
diff --git a/benchmark/erb_render.yml b/benchmark/erb_render.yml
new file mode 100644
index 0000000000..33f23b2761
--- /dev/null
+++ b/benchmark/erb_render.yml
@@ -0,0 +1,28 @@
+benchmark:
+  erb_render: |
+    require 'erb'
+
+    data = <<erb
+    <html>
+      <head> <%= title %> </head>
+      <body>
+        <h1> <%= title %> </h1>
+        <p>
+          <%= content %>
+        </p>
+      </body>
+    </html>
+    erb
+
+    max = 1_500_000
+    title = "hello world!"
+    content = "hello world!\n" * 10
+
+    src = "def self.render(title, content); #{ERB.new(data).src}; end"
+    mod = Module.new
+    mod.instance_eval(src, "(ERB)")
+
+    max.times do
+      mod.render(title, content)
+    end
+loop_count: 1
diff --git a/benchmark/file_chmod.yml b/benchmark/file_chmod.yml
new file mode 100644
index 0000000000..baa43ddd42
--- /dev/null
+++ b/benchmark/file_chmod.yml
@@ -0,0 +1,13 @@
+prelude: |
+  # chmod file
+benchmark:
+  file_chmod: |
+    require 'tempfile'
+    max = 200_000
+    tmp = Tempfile.new('chmod')
+    path = tmp.path
+    max.times do
+      File.chmod(0777, path)
+    end
+    tmp.close!
+loop_count: 1
diff --git a/benchmark/file_rename.yml b/benchmark/file_rename.yml
new file mode 100644
index 0000000000..36a94d0b9b
--- /dev/null
+++ b/benchmark/file_rename.yml
@@ -0,0 +1,15 @@
+prelude: |
+  # rename file
+benchmark:
+  file_rename: |
+    require 'tempfile'
+
+    max = 100_000
+    tmp = [ Tempfile.new('rename-a'), Tempfile.new('rename-b') ]
+    a, b = tmp.map { |x| x.path }
+    max.times do
+      File.rename(a, b)
+      File.rename(b, a)
+    end
+    tmp.each { |t| t.close! }
+loop_count: 1
diff --git a/benchmark/hash_aref_dsym.yml b/benchmark/hash_aref_dsym.yml
new file mode 100644
index 0000000000..e862b5689c
--- /dev/null
+++ b/benchmark/hash_aref_dsym.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_aref_dsym: |
+    h = {}
+    syms = ('a'..'z').map { |s| s.to_sym }
+    syms.each { |s| h[s] = 1 }
+    200_000.times { syms.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_aref_dsym_long.yml b/benchmark/hash_aref_dsym_long.yml
new file mode 100644
index 0000000000..5488e052cd
--- /dev/null
+++ b/benchmark/hash_aref_dsym_long.yml
@@ -0,0 +1,25 @@
+prelude: |
+  # [ruby-core:70129] [Bug #11396]
+benchmark:
+  hash_aref_dsym_long: |
+    collection_size = 200000
+    sample_size = 10000
+
+    values = (1..collection_size).to_a.map do |x|
+      "THIS IS A LONGER STRING THAT IS ALSO UNIQUE #{x}"
+    end
+
+    symbol_hash = {}
+
+    values.each do |x|
+      symbol_hash[x.to_sym] = 1
+    end
+
+    # use the same samples each time to minimize deviations
+    rng = Random.new(0)
+    symbol_sample_array = values.sample(sample_size, random: rng).map(&:to_sym)
+
+    3000.times do
+      symbol_sample_array.each { |x| symbol_hash[x] }
+    end
+loop_count: 1
diff --git a/benchmark/hash_aref_fix.yml b/benchmark/hash_aref_fix.yml
new file mode 100644
index 0000000000..5469d2a2db
--- /dev/null
+++ b/benchmark/hash_aref_fix.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_aref_fix: |
+    h = {}
+    nums = (1..26).to_a
+    nums.each { |i| h[i] = i }
+    200_000.times { nums.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_aref_flo.yml b/benchmark/hash_aref_flo.yml
new file mode 100644
index 0000000000..2e3d8c887b
--- /dev/null
+++ b/benchmark/hash_aref_flo.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_aref_flo: |
+    h = {}
+    strs = [*1..10000].map! {|i| i.fdiv(10)}
+    strs.each { |s| h[s] = s }
+    50.times { strs.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_aref_miss.yml b/benchmark/hash_aref_miss.yml
new file mode 100644
index 0000000000..4bd541e2ff
--- /dev/null
+++ b/benchmark/hash_aref_miss.yml
@@ -0,0 +1,8 @@
+benchmark:
+  hash_aref_miss: |
+    h = {}
+    strs = ('a'..'z').to_a.map!(&:freeze)
+    strs.each { |s| h[s] = s }
+    strs = ('A'..'Z').to_a
+    200_000.times { strs.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_aref_str.yml b/benchmark/hash_aref_str.yml
new file mode 100644
index 0000000000..0790320ec5
--- /dev/null
+++ b/benchmark/hash_aref_str.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_aref_str: |
+    h = {}
+    strs = ('a'..'z').to_a.map!(&:freeze)
+    strs.each { |s| h[s] = s }
+    200_000.times { strs.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_aref_sym.yml b/benchmark/hash_aref_sym.yml
new file mode 100644
index 0000000000..e289d4aff3
--- /dev/null
+++ b/benchmark/hash_aref_sym.yml
@@ -0,0 +1,12 @@
+benchmark:
+  hash_aref_sym: |
+    h = {}
+    syms = ('a'..'z').to_a
+    begin
+      syms = eval("%i[#{syms.join(' ')}]")
+    rescue SyntaxError # <= 1.9.3
+      syms.map!(&:to_sym)
+    end
+    syms.each { |s| h[s] = s }
+    200_000.times { syms.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_aref_sym_long.yml b/benchmark/hash_aref_sym_long.yml
new file mode 100644
index 0000000000..4edccc12dd
--- /dev/null
+++ b/benchmark/hash_aref_sym_long.yml
@@ -0,0 +1,16 @@
+benchmark:
+  hash_aref_sym_long: |
+    h = {}
+    syms = %w[puts warn syswrite write stat bacon lettuce tomato
+    some symbols in this array may already be interned  others should not be
+    hash browns make good breakfast but not cooked using prime numbers
+    shift for division entries delete_if keys exist?
+    ]
+    begin
+      syms = eval("%i[#{syms.join(' ')}]")
+    rescue SyntaxError # <= 1.9.3
+      syms.map!(&:to_sym)
+    end
+    syms.each { |s| h[s] = s }
+    200_000.times { syms.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_flatten.yml b/benchmark/hash_flatten.yml
new file mode 100644
index 0000000000..0412388417
--- /dev/null
+++ b/benchmark/hash_flatten.yml
@@ -0,0 +1,12 @@
+benchmark:
+  hash_flatten: |
+    h = {}
+
+    10000.times do |i|
+      h[i] = nil
+    end
+
+    1000.times do
+      h.flatten
+    end
+loop_count: 1
diff --git a/benchmark/hash_ident_flo.yml b/benchmark/hash_ident_flo.yml
new file mode 100644
index 0000000000..ee2a78db44
--- /dev/null
+++ b/benchmark/hash_ident_flo.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_ident_flo: |
+    h = {}.compare_by_identity
+    strs = (1..10000).to_a.map!(&:to_f)
+    strs.each { |s| h[s] = s }
+    50.times { strs.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_ident_num.yml b/benchmark/hash_ident_num.yml
new file mode 100644
index 0000000000..c9b58bd0c6
--- /dev/null
+++ b/benchmark/hash_ident_num.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_ident_num: |
+    h = {}.compare_by_identity
+    nums = (1..26).to_a
+    nums.each { |n| h[n] = n }
+    200_000.times { nums.each { |n| h[n] } }
+loop_count: 1
diff --git a/benchmark/hash_ident_obj.yml b/benchmark/hash_ident_obj.yml
new file mode 100644
index 0000000000..95c310985f
--- /dev/null
+++ b/benchmark/hash_ident_obj.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_ident_obj: |
+    h = {}.compare_by_identity
+    objs = 26.times.map { Object.new }
+    objs.each { |o| h[o] = o }
+    200_000.times { objs.each { |o| h[o] } }
+loop_count: 1
diff --git a/benchmark/hash_ident_str.yml b/benchmark/hash_ident_str.yml
new file mode 100644
index 0000000000..c2423778f7
--- /dev/null
+++ b/benchmark/hash_ident_str.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_ident_str: |
+    h = {}.compare_by_identity
+    strs = ('a'..'z').to_a
+    strs.each { |s| h[s] = s }
+    200_000.times { strs.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_ident_sym.yml b/benchmark/hash_ident_sym.yml
new file mode 100644
index 0000000000..e49bdba7f4
--- /dev/null
+++ b/benchmark/hash_ident_sym.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_ident_sym: |
+    h = {}.compare_by_identity
+    syms = ('a'..'z').to_a.map(&:to_sym)
+    syms.each { |s| h[s] = s }
+    200_000.times { syms.each { |s| h[s] } }
+loop_count: 1
diff --git a/benchmark/hash_keys.yml b/benchmark/hash_keys.yml
new file mode 100644
index 0000000000..18e9078640
--- /dev/null
+++ b/benchmark/hash_keys.yml
@@ -0,0 +1,12 @@
+benchmark:
+  hash_keys: |
+    h = {}
+
+    10000.times do |i|
+      h[i] = nil
+    end
+
+    5000.times do
+      h.keys
+    end
+loop_count: 1
diff --git a/benchmark/hash_long.yml b/benchmark/hash_long.yml
new file mode 100644
index 0000000000..33c0c38f49
--- /dev/null
+++ b/benchmark/hash_long.yml
@@ -0,0 +1,7 @@
+benchmark:
+  hash_long: |
+    k1 = "Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong";
+    k2 = "Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping Pong Ping";
+    h = {k1 => 0, k2 => 0};
+    3000000.times{|i| k = i % 2 ? k2 : k1; h [k] = h[k] + 1}
+loop_count: 1
diff --git a/benchmark/hash_shift.yml b/benchmark/hash_shift.yml
new file mode 100644
index 0000000000..954c1eb6fe
--- /dev/null
+++ b/benchmark/hash_shift.yml
@@ -0,0 +1,13 @@
+benchmark:
+  hash_shift: |
+    h = {}
+
+    10000.times do |i|
+      h[i] = nil
+    end
+
+    50000.times do
+      k, v = h.shift
+      h[k] = v
+    end
+loop_count: 1
diff --git a/benchmark/hash_shift_u16.yml b/benchmark/hash_shift_u16.yml
new file mode 100644
index 0000000000..b8e1ae75f4
--- /dev/null
+++ b/benchmark/hash_shift_u16.yml
@@ -0,0 +1,13 @@
+benchmark:
+  hash_shift_u16: |
+    h = {}
+
+    (16384..65536).each do |i|
+      h[i] = nil
+    end
+
+    300000.times do
+      k, v = h.shift
+      h[k] = v
+    end
+loop_count: 1
diff --git a/benchmark/hash_shift_u24.yml b/benchmark/hash_shift_u24.yml
new file mode 100644
index 0000000000..743d3cefc3
--- /dev/null
+++ b/benchmark/hash_shift_u24.yml
@@ -0,0 +1,13 @@
+benchmark:
+  hash_shift_u24: |
+    h = {}
+
+    (0xff4000..0xffffff).each do |i|
+      h[i] = nil
+    end
+
+    300000.times do
+      k, v = h.shift
+      h[k] = v
+    end
+loop_count: 1
diff --git a/benchmark/hash_shift_u32.yml b/benchmark/hash_shift_u32.yml
new file mode 100644
index 0000000000..96e9753dde
--- /dev/null
+++ b/benchmark/hash_shift_u32.yml
@@ -0,0 +1,13 @@
+benchmark:
+  hash_shift_u32: |
+    h = {}
+
+    (0xffff4000..0xffffffff).each do |i|
+      h[i] = nil
+    end
+
+    300000.times do
+      k, v = h.shift
+      h[k] = v
+    end
+loop_count: 1
diff --git a/benchmark/hash_small2.yml b/benchmark/hash_small2.yml
new file mode 100644
index 0000000000..0bf7ab6a1b
--- /dev/null
+++ b/benchmark/hash_small2.yml
@@ -0,0 +1,4 @@
+benchmark:
+  hash_small2: |
+    1000000.times.map{|i| a={}; 2.times{|j| a[j]=j}; a}
+loop_count: 1
diff --git a/benchmark/hash_small4.yml b/benchmark/hash_small4.yml
new file mode 100644
index 0000000000..24bc334c63
--- /dev/null
+++ b/benchmark/hash_small4.yml
@@ -0,0 +1,4 @@
+benchmark:
+  hash_small4: |
+    1000000.times.map{|i| a={}; 4.times{|j| a[j]=j}; a}
+loop_count: 1
diff --git a/benchmark/hash_small8.yml b/benchmark/hash_small8.yml
new file mode 100644
index 0000000000..30b50a789c
--- /dev/null
+++ b/benchmark/hash_small8.yml
@@ -0,0 +1,4 @@
+benchmark:
+  hash_small8: |
+    1000000.times.map{|i| a={}; 8.times{|j| a[j]=j}; a}
+loop_count: 1
diff --git a/benchmark/hash_to_proc.yml b/benchmark/hash_to_proc.yml
new file mode 100644
index 0000000000..2ae8588b27
--- /dev/null
+++ b/benchmark/hash_to_proc.yml
@@ -0,0 +1,12 @@
+benchmark:
+  hash_to_proc: |
+    h = {}
+
+    10000.times do |i|
+      h[i] = nil
+    end
+
+    5000.times do |i|
+      [i].map(&h)
+    end
+loop_count: 1
diff --git a/benchmark/hash_values.yml b/benchmark/hash_values.yml
new file mode 100644
index 0000000000..b645bcf4f8
--- /dev/null
+++ b/benchmark/hash_values.yml
@@ -0,0 +1,12 @@
+benchmark:
+  hash_values: |
+    h = {}
+
+    10000.times do |i|
+      h[i] = nil
+    end
+
+    5000.times do
+      h.values
+    end
+loop_count: 1
diff --git a/benchmark/int_quo.yml b/benchmark/int_quo.yml
new file mode 100644
index 0000000000..1527de3dfc
--- /dev/null
+++ b/benchmark/int_quo.yml
@@ -0,0 +1,4 @@
+benchmark:
+  int_quo: |
+    5000000.times { 42.quo(3) }
+loop_count: 1
diff --git a/benchmark/io_copy_stream_write.yml b/benchmark/io_copy_stream_write.yml
new file mode 100644
index 0000000000..32fa920951
--- /dev/null
+++ b/benchmark/io_copy_stream_write.yml
@@ -0,0 +1,28 @@
+prelude: |
+  # The goal of this is to use a synthetic (non-IO) reader
+  # to trigger the read/write loop of IO.copy_stream,
+  # bypassing in-kernel mechanisms like sendfile for zero copy,
+  # so we wrap the /dev/zero IO object:
+benchmark:
+  io_copy_stream_write: |
+
+    class Zero
+      def initialize
+        @n = 100000
+        @in = File.open('/dev/zero', 'rb')
+      end
+
+      def read(len, buf)
+        return if (@n -= 1) == 0
+        @in.read(len, buf)
+      end
+    end
+
+    begin
+      src = Zero.new
+      dst = File.open(IO::NULL, 'wb')
+      n = IO.copy_stream(src, dst)
+    rescue Errno::ENOENT
+      # not *nix
+    end if IO.respond_to?(:copy_stream) && IO.const_defined?(:NULL)
+loop_count: 1
diff --git a/benchmark/io_copy_stream_write_socket.yml b/benchmark/io_copy_stream_write_socket.yml
new file mode 100644
index 0000000000..2207eca8c6
--- /dev/null
+++ b/benchmark/io_copy_stream_write_socket.yml
@@ -0,0 +1,39 @@
+prelude: |
+  # The goal of this is to use a synthetic (non-IO) reader
+  # to trigger the read/write loop of IO.copy_stream,
+  # bypassing in-kernel mechanisms like sendfile for zero copy,
+  # so we wrap the /dev/zero IO object:
+benchmark:
+  io_copy_stream_write_socket: |
+    class Zero
+      def initialize
+        @n = 100000
+        @in = File.open('/dev/zero', 'rb')
+      end
+
+      def read(len, buf)
+        return if (@n -= 1) == 0
+        @in.read(len, buf)
+      end
+    end
+
+    begin
+      require 'socket'
+      src = Zero.new
+      rd, wr = UNIXSocket.pair
+      pid = fork do
+        wr.close
+        buf = String.new
+        while rd.read(16384, buf)
+        end
+      end
+      rd.close
+      IO.copy_stream(src, wr)
+    rescue Errno::ENOENT, NotImplementedError, NameError
+      # not *nix: missing /dev/zero, fork, or UNIXSocket
+    rescue LoadError # no socket?
+    ensure
+      wr.close if wr
+      Process.waitpid(pid) if pid
+    end if IO.respond_to?(:copy_stream)
+loop_count: 1
diff --git a/benchmark/io_file_create.yml b/benchmark/io_file_create.yml
new file mode 100644
index 0000000000..ece11cc332
--- /dev/null
+++ b/benchmark/io_file_create.yml
@@ -0,0 +1,15 @@
+benchmark:
+  io_file_create: |
+    #
+    # Create files
+    #
+
+    max = 200_000
+    file = './tmpfile_of_bm_io_file_create'
+
+    max.times{
+      f = open(file, 'w')
+      f.close#(true)
+    }
+    File.unlink(file)
+loop_count: 1
diff --git a/benchmark/io_file_read.yml b/benchmark/io_file_read.yml
new file mode 100644
index 0000000000..f8f0c1c871
--- /dev/null
+++ b/benchmark/io_file_read.yml
@@ -0,0 +1,18 @@
+benchmark:
+  io_file_read: |
+    #
+    # Seek and Read file.
+    #
+
+    require 'tempfile'
+
+    max = 200_000
+    str = "Hello world!  " * 1000
+    f = Tempfile.new('yarv-benchmark')
+    f.write str
+
+    max.times{
+      f.seek 0
+      f.read
+    }
+loop_count: 1
diff --git a/benchmark/io_file_write.yml b/benchmark/io_file_write.yml
new file mode 100644
index 0000000000..68af6d588c
--- /dev/null
+++ b/benchmark/io_file_write.yml
@@ -0,0 +1,17 @@
+benchmark:
+  io_file_write: |
+    #
+    # Seek and Write file.
+    #
+
+    require 'tempfile'
+
+    max = 200_000
+    str = "Hello world!  " * 1000
+    f = Tempfile.new('yarv-benchmark')
+
+    max.times{
+      f.seek 0
+      f.write str
+    }
+loop_count: 1
diff --git a/benchmark/io_nonblock_noex.yml b/benchmark/io_nonblock_noex.yml
new file mode 100644
index 0000000000..6e29240bd7
--- /dev/null
+++ b/benchmark/io_nonblock_noex.yml
@@ -0,0 +1,25 @@
+benchmark:
+  io_nonblock_noex: |
+    nr = 1_000_000
+    i = 0
+    msg = '.'
+    buf = '.'
+    noex = { exception: false }
+    begin
+      r, w = IO.pipe
+      while i < nr
+        i += 1
+        w.write_nonblock(msg, noex)
+        r.read_nonblock(1, buf, noex)
+      end
+    rescue ArgumentError # old Rubies
+      while i < nr
+        i += 1
+        w.write_nonblock(msg)
+        r.read_nonblock(1, buf)
+      end
+    ensure
+      r.close
+      w.close
+    end
+loop_count: 1
diff --git a/benchmark/io_nonblock_noex2.yml b/benchmark/io_nonblock_noex2.yml
new file mode 100644
index 0000000000..eda8687028
--- /dev/null
+++ b/benchmark/io_nonblock_noex2.yml
@@ -0,0 +1,24 @@
+benchmark:
+  io_nonblock_noex2: |
+    nr = 1_000_000
+    i = 0
+    msg = '.'
+    buf = '.'
+    begin
+      r, w = IO.pipe
+      while i < nr
+        i += 1
+        w.write_nonblock(msg, exception: false)
+        r.read_nonblock(1, buf, exception: false)
+      end
+    rescue ArgumentError # old Rubies
+      while i < nr
+        i += 1
+        w.write_nonblock(msg)
+        r.read_nonblock(1, buf)
+      end
+    ensure
+      r.close
+      w.close
+    end
+loop_count: 1
diff --git a/benchmark/io_pipe_rw.yml b/benchmark/io_pipe_rw.yml
new file mode 100644
index 0000000000..cd9e6c3826
--- /dev/null
+++ b/benchmark/io_pipe_rw.yml
@@ -0,0 +1,17 @@
+prelude: |
+  # Measure uncontended GVL performance via read/write with 1:1 threading
+  # If we switch to M:N threading, this will benchmark something else...
+benchmark:
+  io_pipe_rw: |
+    r, w = IO.pipe
+    src = '0'.freeze
+    dst = String.new
+    i = 0
+    while i < 1_000_000
+      i += 1
+      w.write(src)
+      r.read(1, dst)
+    end
+    w.close
+    r.close
+loop_count: 1
diff --git a/benchmark/io_select.yml b/benchmark/io_select.yml
new file mode 100644
index 0000000000..bcea6b9a70
--- /dev/null
+++ b/benchmark/io_select.yml
@@ -0,0 +1,12 @@
+prelude: |
+  # IO.select performance
+benchmark:
+  io_select: |
+
+    w = [ IO.pipe[1] ];
+
+    nr = 1000000
+    nr.times {
+      IO.select nil, w
+    }
+loop_count: 1
diff --git a/benchmark/io_select2.yml b/benchmark/io_select2.yml
new file mode 100644
index 0000000000..3c8078dc11
--- /dev/null
+++ b/benchmark/io_select2.yml
@@ -0,0 +1,25 @@
+prelude: |
+  # IO.select performance. worst case of single fd.
+benchmark:
+  io_select2: |
+
+    ios = []
+    nr = 1000000
+    if defined?(Process::RLIMIT_NOFILE)
+      max = Process.getrlimit(Process::RLIMIT_NOFILE)[0]
+    else
+      max = 64
+    end
+    puts "max fd: #{max} (results not apparent with <= 1024 max fd)"
+
+    ((max / 2) - 10).times do
+      ios.concat IO.pipe
+    end
+
+    last = [ ios[-1] ]
+    puts "last IO: #{last[0].inspect}"
+
+    nr.times do
+      IO.select nil, last
+    end
+loop_count: 1
diff --git a/benchmark/io_select3.yml b/benchmark/io_select3.yml
new file mode 100644
index 0000000000..c97d0e0cd1
--- /dev/null
+++ b/benchmark/io_select3.yml
@@ -0,0 +1,24 @@
+prelude: |
+  # IO.select performance. a lot of fd
+benchmark:
+  io_select3: |
+
+    ios = []
+    nr = 100
+    if defined?(Process::RLIMIT_NOFILE)
+      max = Process.getrlimit(Process::RLIMIT_NOFILE)[0]
+    else
+      max = 64
+    end
+    puts "max fd: #{max} (results not apparent with <= 1024 max fd)"
+
+    (max - 10).times do
+      r, w = IO.pipe
+      r.close
+      ios.push w
+    end
+
+    nr.times do
+      IO.select nil, ios
+    end
+loop_count: 1
diff --git a/benchmark/loop_for.yml b/benchmark/loop_for.yml
new file mode 100644
index 0000000000..99279f014a
--- /dev/null
+++ b/benchmark/loop_for.yml
@@ -0,0 +1,6 @@
+benchmark:
+  loop_for: |
+    for i in 1..30_000_000
+      #
+    end
+loop_count: 1
diff --git a/benchmark/loop_generator.yml b/benchmark/loop_generator.yml
new file mode 100644
index 0000000000..a5a39c085a
--- /dev/null
+++ b/benchmark/loop_generator.yml
@@ -0,0 +1,17 @@
+benchmark:
+  loop_generator: |
+    max = 600000
+
+    if defined? Fiber
+      gen = (1..max).each
+      loop do
+        gen.next
+      end
+    else
+      require 'generator'
+      gen = Generator.new((0..max))
+      while gen.next?
+        gen.next
+      end
+    end
+loop_count: 1
diff --git a/benchmark/loop_times.yml b/benchmark/loop_times.yml
new file mode 100644
index 0000000000..8d50d6edda
--- /dev/null
+++ b/benchmark/loop_times.yml
@@ -0,0 +1,4 @@
+benchmark:
+  loop_times: |
+    30_000_000.times{|e|}
+loop_count: 1
diff --git a/benchmark/loop_whileloop.yml b/benchmark/loop_whileloop.yml
new file mode 100644
index 0000000000..0fa797aed4
--- /dev/null
+++ b/benchmark/loop_whileloop.yml
@@ -0,0 +1,7 @@
+benchmark:
+  loop_whileloop: |
+    i = 0
+    while i<30_000_000 # benchmark loop 1
+      i += 1
+    end
+loop_count: 1
diff --git a/benchmark/loop_whileloop2.yml b/benchmark/loop_whileloop2.yml
new file mode 100644
index 0000000000..2cf83908b3
--- /dev/null
+++ b/benchmark/loop_whileloop2.yml
@@ -0,0 +1,7 @@
+benchmark:
+  loop_whileloop2: |
+    i = 0
+    while i< 6_000_000 # benchmark loop 2
+      i += 1
+    end
+loop_count: 1
diff --git a/benchmark/marshal_dump_flo.yml b/benchmark/marshal_dump_flo.yml
new file mode 100644
index 0000000000..0e3cc1394a
--- /dev/null
+++ b/benchmark/marshal_dump_flo.yml
@@ -0,0 +1,5 @@
+benchmark:
+  marshal_dump_flo: |
+    bug10761 = 10000.times.map { |x| x.to_f }
+    100.times { Marshal.dump(bug10761) }
+loop_count: 1
diff --git a/benchmark/marshal_dump_load_geniv.yml b/benchmark/marshal_dump_load_geniv.yml
new file mode 100644
index 0000000000..6395c1d1cd
--- /dev/null
+++ b/benchmark/marshal_dump_load_geniv.yml
@@ -0,0 +1,13 @@
+benchmark:
+  marshal_dump_load_geniv: |
+    a = ''
+    a.instance_eval do
+      @a = :a
+      @b = :b
+      @c = :c
+    end
+    100000.times do
+      a = Marshal.load(Marshal.dump(a))
+    end
+    #p(a.instance_eval { @a == :a && @b == :b && @c == :c })
+loop_count: 1
diff --git a/benchmark/marshal_dump_load_time.yml b/benchmark/marshal_dump_load_time.yml
new file mode 100644
index 0000000000..0c25c2d677
--- /dev/null
+++ b/benchmark/marshal_dump_load_time.yml
@@ -0,0 +1,4 @@
+benchmark:
+  marshal_dump_load_time: |
+    100000.times { Marshal.load(Marshal.dump(Time.now)) }
+loop_count: 1
diff --git a/benchmark/securerandom.yml b/benchmark/securerandom.yml
new file mode 100644
index 0000000000..187ca2e294
--- /dev/null
+++ b/benchmark/securerandom.yml
@@ -0,0 +1,8 @@
+benchmark:
+  securerandom: |
+    require "securerandom"
+
+    20_0000.times do
+      SecureRandom.random_number(100)
+    end
+loop_count: 1
diff --git a/benchmark/so_ackermann.yml b/benchmark/so_ackermann.yml
new file mode 100644
index 0000000000..4082169f5e
--- /dev/null
+++ b/benchmark/so_ackermann.yml
@@ -0,0 +1,21 @@
+prelude: |
+  #!/usr/bin/ruby
+  # -*- mode: ruby -*-
+  # $Id: ackermann-ruby.code,v 1.4 2004/11/13 07:40:41 bfulgham Exp $
+  # http://www.bagley.org/~doug/shootout/
+benchmark:
+  so_ackermann: |
+
+    def ack(m, n)
+        if m == 0 then
+            n + 1
+        elsif n == 0 then
+            ack(m - 1, 1)
+        else
+            ack(m - 1, ack(m, n - 1))
+        end
+    end
+
+    NUM = 9
+    ack(3, NUM)
+loop_count: 1
diff --git a/benchmark/so_array.yml b/benchmark/so_array.yml
new file mode 100644
index 0000000000..e68643879e
--- /dev/null
+++ b/benchmark/so_array.yml
@@ -0,0 +1,25 @@
+prelude: |
+  #!/usr/bin/ruby
+  # -*- mode: ruby -*-
+  # $Id: ary-ruby.code,v 1.4 2004/11/13 07:41:27 bfulgham Exp $
+  # http://www.bagley.org/~doug/shootout/
+  # with help from Paul Brannan and Mark Hubbart
+benchmark:
+  so_array: |
+
+    n = 9000 # Integer(ARGV.shift || 1)
+
+    x = Array.new(n)
+    y = Array.new(n, 0)
+
+    n.times{|bi|
+      x[bi] = bi + 1
+    }
+
+    (0 .. 999).each do |e|
+      (n-1).step(0,-1) do |bi|
+        y[bi] += x.at(bi)
+      end
+    end
+    # puts "#{y.first} #{y.last}"
+loop_count: 1
diff --git a/benchmark/so_binary_trees.yml b/benchmark/so_binary_trees.yml
new file mode 100644
index 0000000000..9e943d50ff
--- /dev/null
+++ b/benchmark/so_binary_trees.yml
@@ -0,0 +1,66 @@
+prelude: |
+  # The Computer Language Shootout Benchmarks
+  # http://shootout.alioth.debian.org
+benchmark:
+  so_binary_trees: |
+    #
+    # contributed by Jesse Millikan
+
+    # disable output
+    alias puts_orig puts
+    def puts str
+      # disable puts
+    end
+
+    def item_check(tree)
+     if tree[0] == nil
+      tree[1]
+     else
+      tree[1] + item_check(tree[0]) - item_check(tree[2])
+     end
+    end
+
+    def bottom_up_tree(item, depth)
+     if depth > 0
+      item_item = 2 * item
+      depth -= 1
+      [bottom_up_tree(item_item - 1, depth), item, bottom_up_tree(item_item, depth)]
+     else
+      [nil, item, nil]
+     end
+    end
+
+    max_depth = 16 # ARGV[0].to_i
+    min_depth = 4
+
+    max_depth = min_depth + 2 if min_depth + 2 > max_depth
+
+    stretch_depth = max_depth + 1
+    stretch_tree = bottom_up_tree(0, stretch_depth)
+
+    puts "stretch tree of depth #{stretch_depth}\t check: #{item_check(stretch_tree)}"
+    stretch_tree = nil
+
+    long_lived_tree = bottom_up_tree(0, max_depth)
+
+    min_depth.step(max_depth + 1, 2) do |depth|
+     iterations = 2**(max_depth - depth + min_depth)
+
+     check = 0
+
+     for i in 1..iterations
+      temp_tree = bottom_up_tree(i, depth)
+      check += item_check(temp_tree)
+
+      temp_tree = bottom_up_tree(-i, depth)
+      check += item_check(temp_tree)
+     end
+
+     puts "#{iterations * 2}\t trees of depth #{depth}\t check: #{check}"
+    end
+
+    puts "long lived tree of depth #{max_depth}\t check: #{item_check(long_lived_tree)}"
+
+    undef puts
+    alias puts puts_orig
+loop_count: 1
diff --git a/benchmark/so_concatenate.yml b/benchmark/so_concatenate.yml
new file mode 100644
index 0000000000..13d6559745
--- /dev/null
+++ b/benchmark/so_concatenate.yml
@@ -0,0 +1,20 @@
+prelude: |
+  #!/usr/bin/ruby
+  # -*- mode: ruby -*-
+  # $Id: strcat-ruby.code,v 1.4 2004/11/13 07:43:28 bfulgham Exp $
+  # http://www.bagley.org/~doug/shootout/
+  # based on code from Aristarkh A Zagorodnikov and Dat Nguyen
+benchmark:
+  so_concatenate: |
+
+    STUFF = "hello\n"
+    i = 0
+    while i<10
+      i += 1
+      hello = ''
+      4_000_000.times do |e|
+        hello << STUFF
+      end
+    end
+    # puts hello.length
+loop_count: 1
diff --git a/benchmark/so_exception.yml b/benchmark/so_exception.yml
new file mode 100644
index 0000000000..0bfe3718eb
--- /dev/null
+++ b/benchmark/so_exception.yml
@@ -0,0 +1,65 @@
+prelude: |
+  #!/usr/bin/ruby
+  # -*- mode: ruby -*-
+  # $Id: except-ruby.code,v 1.4 2004/11/13 07:41:33 bfulgham Exp $
+  # http://www.bagley.org/~doug/shootout/
+benchmark:
+  so_exception: |
+
+    $HI = 0
+    $LO = 0
+    NUM = 250000 # Integer(ARGV[0] || 1)
+
+
+    class Lo_Exception < Exception
+      def initialize(num)
+        @value = num
+      end
+    end
+
+    class Hi_Exception < Exception
+      def initialize(num)
+        @value = num
+      end
+    end
+
+    def some_function(num)
+      begin
+        hi_function(num)
+      rescue
+        print "We shouldn't get here, exception is: #{$!.type}\n"
+      end
+    end
+
+    def hi_function(num)
+      begin
+        lo_function(num)
+      rescue Hi_Exception
+        $HI = $HI + 1
+      end
+    end
+
+    def lo_function(num)
+      begin
+        blowup(num)
+      rescue Lo_Exception
+        $LO = $LO + 1
+      end
+    end
+
+    def blowup(num)
+      if num % 2 == 0
+        raise Lo_Exception.new(num)
+      else
+        raise Hi_Exception.new(num)
+      end
+    end
+
+
+    i = 1
+    max = NUM+1
+    while i < max
+      i += 1
+      some_function(i+1)
+    end
+loop_count: 1
diff --git a/benchmark/so_fannkuch.yml b/benchmark/so_fannkuch.yml
new file mode 100644
index 0000000000..3d7a2b43bd
--- /dev/null
+++ b/benchmark/so_fannkuch.yml
@@ -0,0 +1,48 @@
+prelude: |
+  # The Computer Language Shootout
+  # http://shootout.alioth.debian.org/
+  # Contributed by Sokolov Yura
+  # Modified by Ryan Williams
+benchmark:
+  so_fannkuch: |
+
+    def fannkuch(n)
+       maxFlips, m, r, check = 0, n-1, n, 0
+       count = (1..n).to_a
+       perm = (1..n).to_a
+
+       while true
+          if check < 30
+             puts "#{perm}"
+             check += 1
+          end
+
+          while r != 1
+             count[r-1] = r
+             r -= 1
+          end
+
+          if perm[0] != 1 and perm[m] != n
+             perml = perm.clone #.dup
+             flips = 0
+             while (k = perml.first ) != 1
+                perml = perml.slice!(0, k).reverse + perml
+                flips += 1
+             end
+             maxFlips = flips if flips > maxFlips
+          end
+          while true
+             if r==n then return maxFlips end
+             perm.insert r,perm.shift
+             break if (count[r] -= 1) > 0
+             r += 1
+          end
+       end
+    end
+
+    def puts *args
+    end
+
+    N = 9 # (ARGV[0] || 1).to_i
+    puts "Pfannkuchen(#{N}) = #{fannkuch(N)}"
+loop_count: 1
diff --git a/benchmark/so_fasta.yml b/benchmark/so_fasta.yml
new file mode 100644
index 0000000000..c7c6a92958
--- /dev/null
+++ b/benchmark/so_fasta.yml
@@ -0,0 +1,84 @@
+prelude: |
+  # The Computer Language Shootout
+  # http://shootout.alioth.debian.org/
+  # Contributed by Sokolov Yura
+benchmark:
+  so_fasta: |
+
+    $last = 42.0
+    def gen_random(max, im=139968, ia=3877, ic=29573)
+        (max * ($last = ($last * ia + ic) % im)) / im
+    end
+
+    alu =
+       "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG"+
+       "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA"+
+       "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT"+
+       "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA"+
+       "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG"+
+       "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC"+
+       "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA"
+
+    iub = [
+        ["a", 0.27],
+        ["c", 0.12],
+        ["g", 0.12],
+        ["t", 0.27],
+
+        ["B", 0.02],
+        ["D", 0.02],
+        ["H", 0.02],
+        ["K", 0.02],
+        ["M", 0.02],
+        ["N", 0.02],
+        ["R", 0.02],
+        ["S", 0.02],
+        ["V", 0.02],
+        ["W", 0.02],
+        ["Y", 0.02],
+    ]
+    homosapiens = [
+        ["a", 0.3029549426680],
+        ["c", 0.1979883004921],
+        ["g", 0.1975473066391],
+        ["t", 0.3015094502008],
+    ]
+
+    def make_repeat_fasta(id, desc, src, n)
+        puts ">#{id} #{desc}"
+        v = nil
+        width = 60
+        l = src.length
+        s = src * ((n / l) + 1)
+        s.slice!(n, l)
+        puts(s.scan(/.{1,#{width}}/).join("\n"))
+    end
+
+    def make_random_fasta(id, desc, table, n)
+        puts ">#{id} #{desc}"
+        rand, v = nil,nil
+        width = 60
+        chunk = 1 * width
+        prob = 0.0
+        table.each{|v| v[1]= (prob += v[1])}
+        for i in 1..(n/width)
+            puts((1..width).collect{
+                rand = gen_random(1.0)
+                table.find{|v| v[1]>rand}[0]
+            }.join)
+        end
+        if n%width != 0
+            puts((1..(n%width)).collect{
+                rand = gen_random(1.0)
+                table.find{|v| v[1]>rand}[0]
+            }.join)
+        end
+    end
+
+
+    n = (ARGV[0] or 250_000).to_i
+
+    make_repeat_fasta('ONE', 'Homo sapiens alu', alu, n*2)
+    make_random_fasta('TWO', 'IUB ambiguity codes', iub, n*3)
+    make_random_fasta('THREE', 'Homo sapiens frequency', homosapiens, n*5)
+loop_count: 1
diff --git a/benchmark/so_lists.yml b/benchmark/so_lists.yml
new file mode 100644
index 0000000000..44a7495a2f
--- /dev/null
+++ b/benchmark/so_lists.yml
@@ -0,0 +1,51 @@
+prelude: |
+  #from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+benchmark:
+  so_lists: |
+
+    NUM = 300
+    SIZE = 10000
+
+    def test_lists()
+      # create a list of integers (Li1) from 1 to SIZE
+      li1 = (1..SIZE).to_a
+      # copy the list to li2 (not by individual items)
+      li2 = li1.dup
+      # remove each individual item from left side of li2 and
+      # append to right side of li3 (preserving order)
+      li3 = Array.new
+      while (not li2.empty?)
+        li3.push(li2.shift)
+      end
+      # li2 must now be empty
+      # remove each individual item from right side of li3 and
+      # append to right side of li2 (reversing list)
+      while (not li3.empty?)
+        li2.push(li3.pop)
+      end
+      # li3 must now be empty
+      # reverse li1 in place
+      li1.reverse!
+      # check that first item is now SIZE
+      if li1[0] != SIZE then
+        p "not SIZE"
+        0
+      else
+        # compare li1 and li2 for equality
+        if li1 != li2 then
+          return(0)
+        else
+          # return the length of the list
+          li1.length
+        end
+      end
+    end
+
+    i = 0
+    while i<NUM
+      i += 1
+      result = test_lists()
+    end
+
+    result
+loop_count: 1
diff --git a/benchmark/so_mandelbrot.yml b/benchmark/so_mandelbrot.yml
new file mode 100644
index 0000000000..daa58a0133
--- /dev/null
+++ b/benchmark/so_mandelbrot.yml
@@ -0,0 +1,61 @@
+prelude: |
+  #  The Computer Language Benchmarks Game
+  #  http://shootout.alioth.debian.org/
+benchmark:
+  so_mandelbrot: |
+    #
+    #  contributed by Karl von Laudermann
+    #  modified by Jeremy Echols
+
+    size = 600 # ARGV[0].to_i
+
+    puts "P4\n#{size} #{size}"
+
+    ITER = 49                           # Iterations - 1 for easy for..in looping
+    LIMIT_SQUARED = 4.0                 # Presquared limit
+
+    byte_acc = 0
+    bit_num = 0
+
+    count_size = size - 1               # Precomputed size for easy for..in looping
+
+    # For..in loops are faster than .upto, .downto, .times, etc.
+    for y in 0..count_size
+      for x in 0..count_size
+        zr = 0.0
+        zi = 0.0
+        cr = (2.0*x/size)-1.5
+        ci = (2.0*y/size)-1.0
+        escape = false
+
+        # To make use of the for..in code, we use a dummy variable,
+        # like one would in C
+        for dummy in 0..ITER
+          tr = zr*zr - zi*zi + cr
+          ti = 2*zr*zi + ci
+          zr, zi = tr, ti
+
+          if (zr*zr+zi*zi) > LIMIT_SQUARED
+            escape = true
+            break
+          end
+        end
+
+        byte_acc = (byte_acc << 1) | (escape ? 0b0 : 0b1)
+        bit_num += 1
+
+        # Code is very similar for these cases, but using separate blocks
+        # ensures we skip the shifting when it's unnecessary, which is most cases.
+        if (bit_num == 8)
+          print byte_acc.chr
+          byte_acc = 0
+          bit_num = 0
+        elsif (x == count_size)
+          byte_acc <<= (8 - bit_num)
+          print byte_acc.chr
+          byte_acc = 0
+          bit_num = 0
+        end
+      end
+    end
+loop_count: 1
diff --git a/benchmark/so_matrix.yml b/benchmark/so_matrix.yml
new file mode 100644
index 0000000000..9a534471d9
--- /dev/null
+++ b/benchmark/so_matrix.yml
@@ -0,0 +1,50 @@
+prelude: |
+  #!/usr/bin/ruby
+  # -*- mode: ruby -*-
+  # $Id: matrix-ruby.code,v 1.4 2004/11/13 07:42:14 bfulgham Exp $
+  # http://www.bagley.org/~doug/shootout/
+benchmark:
+  so_matrix: |
+
+    n = 60 #Integer(ARGV.shift || 1)
+
+    size = 40
+
+    def mkmatrix(rows, cols)
+        count = 1
+        mx = Array.new(rows)
+        (0 .. (rows - 1)).each do |bi|
+            row = Array.new(cols, 0)
+            (0 .. (cols - 1)).each do |j|
+                row[j] = count
+                count += 1
+            end
+            mx[bi] = row
+        end
+        mx
+    end
+
+    def mmult(rows, cols, m1, m2)
+        m3 = Array.new(rows)
+        (0 .. (rows - 1)).each do |bi|
+            row = Array.new(cols, 0)
+            (0 .. (cols - 1)).each do |j|
+                val = 0
+                (0 .. (cols - 1)).each do |k|
+                    val += m1.at(bi).at(k) * m2.at(k).at(j)
+                end
+                row[j] = val
+            end
+            m3[bi] = row
+        end
+        m3
+    end
+
+    m1 = mkmatrix(size, size)
+    m2 = mkmatrix(size, size)
+    mm = Array.new
+    n.times do
+        mm = mmult(size, size, m1, m2)
+    end
+    # puts "#{mm[0][0]} #{mm[2][3]} #{mm[3][2]} #{mm[4][4]}"
+loop_count: 1
diff --git a/benchmark/so_meteor_contest.yml b/benchmark/so_meteor_contest.yml
new file mode 100644
index 0000000000..c35df18f68
--- /dev/null
+++ b/benchmark/so_meteor_contest.yml
@@ -0,0 +1,567 @@
+prelude: |
+  #!/usr/bin/env ruby
+benchmark:
+  so_meteor_contest: |
+    #
+    # The Computer Language Shootout
+    #   http://shootout.alioth.debian.org
+    #   contributed by Kevin Barnes (Ruby novice)
+
+    # PROGRAM:  the main body is at the bottom.
+    #   1) read about the problem here: http://www-128.ibm.com/developerworks/java/library/j-javaopt/
+    #   2) see how I represent a board as a bitmask by reading the blank_board comments
+    #   3) read as your mental paths take you
+
+    def print *args
+    end
+
+    # class to represent all information about a particular rotation of a particular piece
+    class Rotation
+      # an array (by location) containing a bit mask for how the piece maps at the given location.
+      # if the rotation is invalid at that location the mask will contain false
+      attr_reader :start_masks
+
+      # maps a direction to a relative location.  these differ depending on whether it is an even or
+      # odd row being mapped from
+      @@rotation_even_adder = { :west => -1, :east => 1, :nw => -7, :ne => -6, :sw => 5, :se => 6 }
+      @@rotation_odd_adder = { :west => -1, :east => 1, :nw => -6, :ne => -5, :sw => 6, :se => 7 }
+
+      def initialize( directions )
+        @even_offsets, @odd_offsets = normalize_offsets( get_values( directions ))
+
+        @even_mask = mask_for_offsets( @even_offsets)
+        @odd_mask = mask_for_offsets( @odd_offsets)
+
+        @start_masks = Array.new(60)
+
+        # create the rotational masks by placing the base mask at the location and seeing if
+        # 1) it overlaps the boundaries and 2) it produces a prunable board.  if either of these
+        # is true the piece cannot be placed
+        0.upto(59) do | offset |
+          mask = is_even(offset) ? (@even_mask << offset) : (@odd_mask << offset)
+          if (blank_board & mask == 0 && !prunable(blank_board | mask, 0, true)) then
+            imask = compute_required( mask, offset)
+            @start_masks[offset] = [ mask, imask, imask | mask ]
+          else
+            @start_masks[offset] = false
+          end
+        end
+      end
+
+      def compute_required( mask, offset )
+        board = blank_board
+        0.upto(offset) { | i | board |= 1 << i }
+        board |= mask
+        return 0 if (!prunable(board | mask, offset))
+        board = flood_fill(board,58)
+        count = 0
+        imask = 0
+        0.upto(59) do | i |
+          if (board[i] == 0) then
+            imask |= (1 << i)
+            count += 1
+          end
+        end
+        (count > 0 && count < 5) ? imask : 0
+      end
+
+      def flood_fill( board, location)
+        return board if (board[location] == 1)
+        board |= 1 << location
+        row, col = location.divmod(6)
+        board = flood_fill( board, location - 1) if (col > 0)
+        board = flood_fill( board, location + 1) if (col < 4)
+        if (row % 2 == 0) then
+          board = flood_fill( board, location - 7) if (col > 0 && row > 0)
+          board = flood_fill( board, location - 6) if (row > 0)
+          board = flood_fill( board, location + 6) if (row < 9)
+          board = flood_fill( board, location + 5) if (col > 0 && row < 9)
+        else
+          board = flood_fill( board, location - 5) if (col < 4 && row > 0)
+          board = flood_fill( board, location - 6) if (row > 0)
+          board = flood_fill( board, location + 6) if (row < 9)
+          board = flood_fill( board, location + 7) if (col < 4 && row < 9)
+        end
+        board
+      end
+
+      # given a location, produces a list of relative locations covered by the piece at this rotation
+      def offsets( location)
+        if is_even( location) then
+          @even_offsets.collect { | value | value + location }
+        else
+          @odd_offsets.collect { | value | value + location }
+        end
+      end
+
+      # returns a set of offsets relative to the top-left most piece of the rotation (by even or odd rows)
+      # this is hard to explain. imagine we have this partial board:
+      #   0 0 0 0 0 x        [positions 0-5]
+      #    0 0 1 1 0 x       [positions 6-11]
+      #   0 0 1 0 0 x        [positions 12-17]
+      #    0 1 0 0 0 x       [positions 18-23]
+      #   0 1 0 0 0 x        [positions 24-29]
+      #    0 0 0 0 0 x       [positions 30-35]
+      #       ...
+      # The top-left of the piece is at position 8, the
+      # board would be passed as a set of positions (values array) containing [8,9,14,19,25] not necessarily in that
+      # sorted order.  Since that array starts on an odd row, the offsets for an odd row are: [0,1,6,11,17] obtained
+      # by subtracting 8 from everything.  Now imagine the piece shifted up and to the right so it's on an even row:
+      #   0 0 0 1 1 x        [positions 0-5]
+      #    0 0 1 0 0 x       [positions 6-11]
+      #   0 0 1 0 0 x        [positions 12-17]
+      #    0 1 0 0 0 x       [positions 18-23]
+      #   0 0 0 0 0 x        [positions 24-29]
+      #    0 0 0 0 0 x       [positions 30-35]
+      #       ...
+      # Now the positions are [3,4,8,14,19] which after subtracting the lowest value (3) gives [0,1,5,11,16] thus, the
+      # offsets for this particular piece are (in even, odd order) [0,1,5,11,16],[0,1,6,11,17] which is what
+      # this function would return
+      def normalize_offsets( values)
+        min = values.min
+        even_min = is_even(min)
+        other_min = even_min ? min + 6 : min + 7
+        other_values = values.collect do | value |
+          if is_even(value) then
+            value + 6 - other_min
+          else
+            value + 7 - other_min
+          end
+        end
+        values.collect! { | value | value - min }
+
+        if even_min then
+          [values, other_values]
+        else
+          [other_values, values]
+        end
+      end
+
+      # produce a bitmask representation of an array of offset locations
+      def mask_for_offsets( offsets )
+        mask = 0
+        offsets.each { | value | mask = mask + ( 1 << value ) }
+        mask
+      end
+
+      # finds a "safe" position that a position as described by a list of directions can be placed
+      # without falling off any edge of the board.  the values returned a location to place the first piece
+      # at so it will fit after making the described moves
+      def start_adjust( directions )
+        south = east = 0;
+        directions.each do | direction |
+          east += 1 if ( direction == :sw || direction == :nw || direction == :west )
+          south += 1 if ( direction == :nw || direction == :ne )
+        end
+        south * 6 + east
+      end
+
+      # given a set of directions places the piece (as defined by a set of directions) on the board at
+      # a location that will not take it off the edge
+      def get_values( directions )
+        start = start_adjust(directions)
+        values = [ start ]
+        directions.each do | direction |
+          if (start % 12 >= 6) then
+            start += @@rotation_odd_adder[direction]
+          else
+            start += @@rotation_even_adder[direction]
+          end
+          values += [ start ]
+        end
+
+        # some moves take you back to an existing location, we'll strip duplicates
+        values.uniq
+      end
+    end
+
+    # describes a piece and caches information about its rotations to as to be efficient for iteration
+    # ATTRIBUTES:
+    #   rotations -- all the rotations of the piece
+    #   type -- a numeic "name" of the piece
+    #   masks -- an array by location of all legal rotational masks (a n inner array) for that location
+    #   placed -- the mask that this piece was last placed at (not a location, but the actual mask used)
+    class Piece
+      attr_reader :rotations, :type, :masks
+      attr_accessor :placed
+
+      # transform hashes that change one direction into another when you either flip or rotate a set of directions
+      @@flip_converter = { :west => :west, :east => :east, :nw => :sw, :ne => :se, :sw => :nw, :se => :ne }
+      @@rotate_converter = { :west => :nw, :east => :se, :nw => :ne, :ne => :east, :sw => :west, :se => :sw }
+
+      def initialize( directions, type )
+        @type = type
+        @rotations = Array.new();
+        @map = {}
+
+        generate_rotations( directions )
+        directions.collect! { | value | @@flip_converter[value] }
+        generate_rotations( directions )
+
+        # creates the masks AND a map that returns [location, rotation] for any given mask
+        # this is used when a board is found and we want to draw it, otherwise the map is unused
+        @masks = Array.new();
+        0.upto(59) do | i |
+          even = true
+          @masks[i] = @rotations.collect do | rotation |
+            mask = rotation.start_masks[i]
+            @map[mask[0]] = [ i, rotation ] if (mask)
+            mask || nil
+          end
+          @masks[i].compact!
+        end
+      end
+
+      # rotates a set of directions through all six angles and adds a Rotation to the list for each one
+      def generate_rotations( directions )
+        6.times do
+          rotations.push( Rotation.new(directions))
+          directions.collect! { | value | @@rotate_converter[value] }
+        end
+      end
+
+      # given a board string, adds this piece to the board at whatever location/rotation
+      # important: the outbound board string is 5 wide, the normal location notation is six wide (padded)
+      def fill_string( board_string)
+        location, rotation = @map[@placed]
+        rotation.offsets(location).each do | offset |
+          row, col = offset.divmod(6)
+          board_string[ row*5 + col, 1 ] = @type.to_s
+        end
+      end
+    end
+
+    # a blank bit board having this form:
+    #
+    #    0 0 0 0 0 1
+    #     0 0 0 0 0 1
+    #    0 0 0 0 0 1
+    #     0 0 0 0 0 1
+    #    0 0 0 0 0 1
+    #     0 0 0 0 0 1
+    #    0 0 0 0 0 1
+    #     0 0 0 0 0 1
+    #    0 0 0 0 0 1
+    #     0 0 0 0 0 1
+    #    1 1 1 1 1 1
+    #
+    # where left lest significant bit is the top left and the most significant is the lower right
+    # the actual board only consists of the 0 places, the 1 places are blockers to keep things from running
+    # off the edges or bottom
+    def blank_board
+      0b111111100000100000100000100000100000100000100000100000100000100000
+    end
+
+    def full_board
+      0b111111111111111111111111111111111111111111111111111111111111111111
+    end
+
+    # determines if a location (bit position) is in an even row
+    def is_even( location)
+      (location % 12) < 6
+    end
+
+    # support function that create three utility maps:
+    #  $converter -- for each row an array that maps a five bit row (via array mapping)
+    #                to the a five bit representation of the bits below it
+    #  $bit_count -- maps a five bit row (via array mapping) to the number of 1s in the row
+    #  @@new_regions -- maps a five bit row (via array mapping) to an array of "region" arrays
+    #                   a region array has three values the first is a mask of bits in the region,
+    #                   the second is the count of those bits and the third is identical to the first
+    #                   examples:
+    #                           0b10010 => [ 0b01100, 2, 0b01100 ], [ 0b00001, 1, 0b00001]
+    #                           0b01010 => [ 0b10000, 1, 0b10000 ], [ 0b00100, 1, 0b00100 ], [ 0b00001, 1, 0b00001]
+    #                           0b10001 => [ 0b01110, 3, 0b01110 ]
+    def create_collector_support
+      odd_map = [0b11, 0b110, 0b1100, 0b11000, 0b10000]
+      even_map = [0b1, 0b11, 0b110, 0b1100, 0b11000]
+
+      all_odds = Array.new(0b100000)
+      all_evens = Array.new(0b100000)
+      bit_counts = Array.new(0b100000)
+      new_regions = Array.new(0b100000)
+      0.upto(0b11111) do | i |
+        bit_count = odd = even = 0
+        0.upto(4) do | bit |
+          if (i[bit] == 1) then
+            bit_count += 1
+            odd |= odd_map[bit]
+            even |= even_map[bit]
+          end
+        end
+        all_odds[i] = odd
+        all_evens[i] = even
+        bit_counts[i] = bit_count
+        new_regions[i] = create_regions( i)
+      end
+
+      $converter = []
+      10.times { | row | $converter.push((row % 2 == 0) ? all_evens : all_odds) }
+      $bit_counts = bit_counts
+      $regions = new_regions.collect { | set | set.collect { | value | [ value, bit_counts[value], value] } }
+    end
+
+    # determines if a board is punable, meaning that there is no possibility that it
+    # can be filled up with pieces.  A board is prunable if there is a grouping of unfilled spaces
+    # that are not a multiple of five.  The following board is an example of a prunable board:
+    #    0 0 1 0 0
+    #     0 1 0 0 0
+    #    1 1 0 0 0
+    #     0 1 0 0 0
+    #    0 0 0 0 0
+    #       ...
+    #
+    # This board is prunable because the top left corner is only 3 bits in area, no piece will ever fit it
+    # parameters:
+    #   board -- an initial bit board (6 bit padded rows, see blank_board for format)
+    #   location -- starting location, everything above and to the left is already full
+    #   slotting -- set to true only when testing initial pieces, when filling normally
+    #               additional assumptions are possible
+    #
+    # Algorithm:
+    #    The algorithm starts at the top row (as determined by location) and iterates a row at a time
+    #    maintainng counts of active open areas (kept in the collector array) each collector contains
+    #    three values at the start of an iteration:
+    #          0: mask of bits that would be adjacent to the collector in this row
+    #          1: the number of bits collected so far
+    #          2: a scratch space starting as zero, but used during the computation to represent
+    #             the empty bits in the new row that are adjacent (position 0)
+    #  The exact procedure is described in-code
+    def prunable( board, location, slotting = false)
+      collectors = []
+      # loop across the rows
+      (location / 6).to_i.upto(9) do | row_on |
+        # obtain a set of regions representing the bits of the current row.
+        regions = $regions[(board >> (row_on * 6)) & 0b11111]
+        converter = $converter[row_on]
+
+        # track the number of collectors at the start of the cycle so that
+        # we don't compute against newly created collectors, only existing collectors
+        initial_collector_count = collectors.length
+
+        # loop against the regions.  For each region of the row
+        # we will see if it connects to one or more existing collectors.
+        # if it connects to 1 collector, the bits from the region are added to the
+        # bits of the collector and the mask is placed in collector[2]
+        # If the region overlaps more than one collector then all the collectors
+        # it overlaps with are merged into the first one (the others are set to nil in the array)
+        # if NO collectors are found then the region is copied as a new collector
+        regions.each do | region |
+          collector_found = nil
+          region_mask = region[2]
+          initial_collector_count.times do | collector_num |
+            collector = collectors[collector_num]
+            if (collector) then
+              collector_mask = collector[0]
+              if (collector_mask & region_mask != 0) then
+                if (collector_found) then
+                  collector_found[0] |= collector_mask
+                  collector_found[1] += collector[1]
+                  collector_found[2] |= collector[2]
+                  collectors[collector_num] = nil
+                else
+                  collector_found = collector
+                  collector[1] += region[1]
+                  collector[2] |= region_mask
+                end
+              end
+            end
+          end
+          if (collector_found == nil) then
+            collectors.push(Array.new(region))
+          end
+        end
+
+        # check the existing collectors, if any collector overlapped no bits in the region its [2] value will
+        # be zero.  The size of any such reaason is tested if it is not a multiple of five true is returned since
+        # the board is prunable.  if it is a multiple of five it is removed.
+        # Collector that are still active have a new adjacent value [0] set based n the matched bits
+        # and have [2] cleared out for the next cycle.
+        collectors.length.times do | collector_num |
+          collector = collectors[collector_num]
+          if (collector) then
+            if (collector[2] == 0) then
+              return true if (collector[1] % 5 != 0)
+              collectors[collector_num] = nil
+            else
+              # if a collector matches all bits in the row then we can return unprunable early for the
+              # following reasons:
+              #    1) there can be no more unavailable bits bince we fill from the top left downward
+              #    2) all previous regions have been closed or joined so only this region can fail
+              #    3) this region must be good since there can never be only 1 region that is nuot
+              #       a multiple of five
+              # this rule only applies when filling normally, so we ignore the rule if we are "slotting"
+              # in pieces to see what configurations work for them (the only other time this algorithm is used).
+              return false if (collector[2] == 0b11111 && !slotting)
+              collector[0] = converter[collector[2]]
+              collector[2] = 0
+            end
+          end
+        end
+
+        # get rid of all the empty converters for the next round
+        collectors.compact!
+      end
+      return false if (collectors.length <= 1) # 1 collector or less and the region is fine
+      collectors.any? { | collector | (collector[1] % 5) != 0 } # more than 1 and we test them all for bad size
+    end
+
+    # creates a region given a row mask.  see prunable for what a "region" is
+    def create_regions( value )
+      regions = []
+      cur_region = 0
+      5.times do | bit |
+        if (value[bit] == 0) then
+          cur_region |= 1 << bit
+        else
+          if (cur_region != 0 ) then
+            regions.push( cur_region)
+            cur_region = 0;
+          end
+        end
+      end
+      regions.push(cur_region) if (cur_region != 0)
+      regions
+    end
+
+    # find up to the counted number of solutions (or all solutions) and prints the final result
+    def find_all
+      find_top( 1)
+      find_top( 0)
+      print_results
+    end
+
+    # show the board
+    def print_results
+      print "#{@boards_found} solutions found\n\n"
+      print_full_board( @min_board)
+      print "\n"
+      print_full_board( @max_board)
+      print "\n"
+    end
+
+    # finds solutions.  This special version of the main function is only used for the top level
+    # the reason for it is basically to force a particular ordering on how the rotations are tested for
+    # the first piece.  It is called twice, first looking for placements of the odd rotations and then
+    # looking for placements of the even locations.
+    #
+    # WHY?
+    #   Since any found solution has an inverse we want to maximize finding solutions that are not already found
+    #   as an inverse.  The inverse will ALWAYS be 3 one of the piece configurations that is exactly 3 rotations away
+    #   (an odd number).  Checking even vs odd then produces a higher probability of finding more pieces earlier
+    #   in the cycle.  We still need to keep checking all the permutations, but our probability of finding one will
+    #   diminsh over time.  Since we are TOLD how many to search for this lets us exit before checking all pieces
+    #   this bennifit is very great when seeking small numbers of solutions and is 0 when looking for more than the
+    #   maximum number
+    def find_top( rotation_skip)
+      board = blank_board
+      (@pieces.length-1).times do
+        piece = @pieces.shift
+        piece.masks[0].each do | mask, imask, cmask |
+          if ((rotation_skip += 1) % 2 == 0) then
+            piece.placed = mask
+            find( 1, 1, board | mask)
+          end
+        end
+        @pieces.push(piece)
+      end
+      piece = @pieces.shift
+      @pieces.push(piece)
+    end
+
+    # the normail find routine, iterates through the available pieces, checks all rotations at the current location
+    # and adds any boards found.  depth is achieved via recursion.  the overall approach is described
+    # here: http://www-128.ibm.com/developerworks/java/library/j-javaopt/
+    # parameters:
+    #  start_location -- where to start looking for place for the next piece at
+    #  placed -- number of pieces placed
+    #  board -- current state of the board
+    #
+    # see in-code comments
+    def find( start_location, placed, board)
+      # find the next location to place a piece by looking for an empty bit
+      while board[start_location] == 1
+        start_location += 1
+      end
+
+      @pieces.length.times do
+        piece = @pieces.shift
+        piece.masks[start_location].each do | mask, imask, cmask |
+          if ( board & cmask == imask) then
+            piece.placed = mask
+            if (placed == 9) then
+              add_board
+            else
+              find( start_location + 1, placed + 1, board | mask)
+            end
+          end
+        end
+        @pieces.push(piece)
+      end
+    end
+
+    # print the board
+    def print_full_board( board_string)
+      10.times do | row |
+        print " " if (row % 2 == 1)
+        5.times do | col |
+          print "#{board_string[row*5 + col,1]} "
+        end
+        print "\n"
+      end
+    end
+
+    # when a board is found we "draw it" into a string and then flip that string, adding both to
+    # the list (hash) of solutions if they are unique.
+    def add_board
+      board_string = "99999999999999999999999999999999999999999999999999"
+      @all_pieces.each {  | piece | piece.fill_string( board_string ) }
+      save( board_string)
+      save( board_string.reverse)
+    end
+
+    # adds a board string to the list (if new) and updates the current best/worst board
+    def save( board_string)
+      if (@all_boards[board_string] == nil) then
+        @min_board = board_string if (board_string < @min_board)
+        @max_board = board_string if (board_string > @max_board)
+        @all_boards.store(board_string,true)
+        @boards_found += 1
+
+        # the exit motif is a time saver.  Ideally the function should return, but those tests
+        # take noticeable time (performance).
+        if (@boards_found == @stop_count) then
+          print_results
+          exit(0)
+        end
+      end
+    end
+
+
+    ##
+    ## MAIN BODY :)
+    ##
+    create_collector_support
+    @pieces = [
+      Piece.new( [ :nw, :ne, :east, :east ], 2),
+      Piece.new( [ :ne, :se, :east, :ne ], 7),
+      Piece.new( [ :ne, :east, :ne, :nw ], 1),
+      Piece.new( [ :east, :sw, :sw, :se ], 6),
+      Piece.new( [ :east, :ne, :se, :ne ], 5),
+      Piece.new( [ :east, :east, :east, :se ], 0),
+      Piece.new( [ :ne, :nw, :se, :east, :se ], 4),
+      Piece.new( [ :se, :se, :se, :west ], 9),
+      Piece.new( [ :se, :se, :east, :se ], 8),
+      Piece.new( [ :east, :east, :sw, :se ], 3)
+      ];
+
+    @all_pieces = Array.new( @pieces)
+
+    @min_board = "99999999999999999999999999999999999999999999999999"
+    @max_board = "00000000000000000000000000000000000000000000000000"
+    @stop_count = ARGV[0].to_i || 2089
+    @all_boards = {}
+    @boards_found = 0
+
+    find_all ######## DO IT!!!
+loop_count: 1
diff --git a/benchmark/so_nbody.yml b/benchmark/so_nbody.yml
new file mode 100644
index 0000000000..e4d111cd38
--- /dev/null
+++ b/benchmark/so_nbody.yml
@@ -0,0 +1,152 @@
+prelude: |
+  # The Computer Language Shootout
+  # http://shootout.alioth.debian.org
+benchmark:
+  so_nbody: |
+    #
+    # Optimized for Ruby by Jesse Millikan
+    # From version ported by Michael Neumann from the C gcc version,
+    # which was written by Christoph Bauer.
+
+    SOLAR_MASS = 4 * Math::PI**2
+    DAYS_PER_YEAR = 365.24
+
+    def _puts *args
+    end
+
+    class Planet
+     attr_accessor :x, :y, :z, :vx, :vy, :vz, :mass
+
+     def initialize(x, y, z, vx, vy, vz, mass)
+      @x, @y, @z = x, y, z
+      @vx, @vy, @vz = vx * DAYS_PER_YEAR, vy * DAYS_PER_YEAR, vz * DAYS_PER_YEAR
+      @mass = mass * SOLAR_MASS
+     end
+
+     def move_from_i(bodies, nbodies, dt, i)
+      while i < nbodies
+       b2 = bodies[i]
+       dx = @x - b2.x
+       dy = @y - b2.y
+       dz = @z - b2.z
+
+       distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
+       mag = dt / (distance * distance * distance)
+       b_mass_mag, b2_mass_mag = @mass * mag, b2.mass * mag
+
+       @vx -= dx * b2_mass_mag
+       @vy -= dy * b2_mass_mag
+       @vz -= dz * b2_mass_mag
+       b2.vx += dx * b_mass_mag
+       b2.vy += dy * b_mass_mag
+       b2.vz += dz * b_mass_mag
+       i += 1
+      end
+
+      @x += dt * @vx
+      @y += dt * @vy
+      @z += dt * @vz
+     end
+    end
+
+    def energy(bodies)
+      e = 0.0
+      nbodies = bodies.size
+
+      for i in 0 ... nbodies
+        b = bodies[i]
+        e += 0.5 * b.mass * (b.vx * b.vx + b.vy * b.vy + b.vz * b.vz)
+        for j in (i + 1) ... nbodies
+          b2 = bodies[j]
+          dx = b.x - b2.x
+          dy = b.y - b2.y
+          dz = b.z - b2.z
+          distance = Math.sqrt(dx * dx + dy * dy + dz * dz)
+          e -= (b.mass * b2.mass) / distance
+        end
+      end
+      e
+    end
+
+    def offset_momentum(bodies)
+      px, py, pz = 0.0, 0.0, 0.0
+
+      for b in bodies
+        m = b.mass
+        px += b.vx * m
+        py += b.vy * m
+        pz += b.vz * m
+      end
+
+      b = bodies[0]
+      b.vx = - px / SOLAR_MASS
+      b.vy = - py / SOLAR_MASS
+      b.vz = - pz / SOLAR_MASS
+    end
+
+    BODIES = [
+      # sun
+      Planet.new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0),
+
+      # jupiter
+      Planet.new(
+        4.84143144246472090e+00,
+        -1.16032004402742839e+00,
+        -1.03622044471123109e-01,
+        1.66007664274403694e-03,
+        7.69901118419740425e-03,
+        -6.90460016972063023e-05,
+        9.54791938424326609e-04),
+
+      # saturn
+      Planet.new(
+        8.34336671824457987e+00,
+        4.12479856412430479e+00,
+        -4.03523417114321381e-01,
+        -2.76742510726862411e-03,
+        4.99852801234917238e-03,
+        2.30417297573763929e-05,
+        2.85885980666130812e-04),
+
+      # uranus
+      Planet.new(
+        1.28943695621391310e+01,
+        -1.51111514016986312e+01,
+        -2.23307578892655734e-01,
+        2.96460137564761618e-03,
+        2.37847173959480950e-03,
+        -2.96589568540237556e-05,
+        4.36624404335156298e-05),
+
+      # neptune
+      Planet.new(
+        1.53796971148509165e+01,
+        -2.59193146099879641e+01,
+        1.79258772950371181e-01,
+        2.68067772490389322e-03,
+        1.62824170038242295e-03,
+        -9.51592254519715870e-05,
+        5.15138902046611451e-05)
+    ]
+
+    init = 200_000 # ARGV[0]
+    n = Integer(init)
+
+    offset_momentum(BODIES)
+
+    puts "%.9f" % energy(BODIES)
+
+    nbodies = BODIES.size
+    dt = 0.01
+
+    n.times do
+      i = 0
+      while i < nbodies
+        b = BODIES[i]
+        b.move_from_i(BODIES, nbodies, dt, i + 1)
+        i += 1
+      end
+    end
+
+    puts "%.9f" % energy(BODIES)
+loop_count: 1
diff --git a/benchmark/so_nested_loop.yml b/benchmark/so_nested_loop.yml
new file mode 100644
index 0000000000..64a6901eac
--- /dev/null
+++ b/benchmark/so_nested_loop.yml
@@ -0,0 +1,26 @@
+prelude: |
+  #!/usr/bin/ruby
+  # -*- mode: ruby -*-
+  # $Id: nestedloop-ruby.code,v 1.4 2004/11/13 07:42:22 bfulgham Exp $
+  # http://www.bagley.org/~doug/shootout/
+  # from Avi Bryant
+benchmark:
+  so_nested_loop: |
+
+    n = 16 # Integer(ARGV.shift || 1)
+    x = 0
+    n.times do
+        n.times do
+            n.times do
+                n.times do
+                    n.times do
+                        n.times do
+                            x += 1
+                        end
+                    end
+                end
+            end
+        end
+    end
+    # puts x
+loop_count: 1
diff --git a/benchmark/so_nsieve.yml b/benchmark/so_nsieve.yml
new file mode 100644
index 0000000000..0799cff7a7
--- /dev/null
+++ b/benchmark/so_nsieve.yml
@@ -0,0 +1,39 @@
+prelude: |
+  # The Computer Language Shootout
+  # http://shootout.alioth.debian.org/
+benchmark:
+  so_nsieve: |
+    #
+    # contributed by Glenn Parker, March 2005
+    # modified by Evan Phoenix, Sept 2006
+
+    def sieve(m)
+      flags = Flags.dup[0,m]
+      count = 0
+      pmax = m - 1
+      p = 2
+      while p <= pmax
+        unless flags[p].zero?
+          count += 1
+          mult = p
+          while mult <= pmax
+            flags[mult] = 0
+            mult += p
+          end
+        end
+        p += 1
+      end
+      count
+    end
+
+    n = 9 # (ARGV[0] || 2).to_i
+    Flags = ("\x1" * ( 2 ** n * 10_000)).unpack("c*")
+
+    n.downto(n-2) do |exponent|
+      break if exponent < 0
+      m = (1 << exponent) * 10_000
+      # m = (2 ** exponent) * 10_000
+      count = sieve(m)
+      printf "Primes up to %8d %8d\n", m, count
+    end
+loop_count: 1
diff --git a/benchmark/so_nsieve_bits.yml b/benchmark/so_nsieve_bits.yml
new file mode 100644
index 0000000000..08b47f53bb
--- /dev/null
+++ b/benchmark/so_nsieve_bits.yml
@@ -0,0 +1,46 @@
+prelude: |
+  #!/usr/bin/ruby
+  #coding: us-ascii
+benchmark:
+  so_nsieve_bits: |
+    #
+    # The Great Computer Language Shootout
+    # http://shootout.alioth.debian.org/
+    #
+    # nsieve-bits in Ruby
+    # Contributed by Glenn Parker, March 2005
+
+    CharExponent = 3
+    BitsPerChar = 1 << CharExponent
+    LowMask = BitsPerChar - 1
+
+    def sieve(m)
+      items = "\xFF" * ((m / BitsPerChar) + 1)
+      masks = ""
+      BitsPerChar.times do |b|
+        masks << (1 << b).chr
+      end
+
+      count = 0
+      pmax = m - 1
+      2.step(pmax, 1) do |p|
+        if items[p >> CharExponent][p & LowMask] == 1
+          count += 1
+          p.step(pmax, p) do |mult|
+    	a = mult >> CharExponent
+    	b = mult & LowMask
+    	items[a] -= masks[b] if items[a][b] != 0
+          end
+        end
+      end
+      count
+    end
+
+    n = 9 # (ARGV[0] || 2).to_i
+    n.step(n - 2, -1) do |exponent|
+      break if exponent < 0
+      m = 2 ** exponent * 10_000
+      count = sieve(m)
+      printf "Primes up to %8d %8d\n", m, count
+    end
+loop_count: 1
diff --git a/benchmark/so_object.yml b/benchmark/so_object.yml
new file mode 100644
index 0000000000..89fbce83cd
--- /dev/null
+++ b/benchmark/so_object.yml
@@ -0,0 +1,59 @@
+prelude: |
+  #!/usr/bin/ruby
+  # -*- mode: ruby -*-
+  # $Id: objinst-ruby.code,v 1.4 2004/11/13 07:42:25 bfulgham Exp $
+  # http://www.bagley.org/~doug/shootout/
+  # with help from Aristarkh Zagorodnikov
+benchmark:
+  so_object: |
+
+    class Toggle
+        def initialize(start_state)
+            @bool = start_state
+        end
+
+        def value
+            @bool
+        end
+
+        def activate
+            @bool = !@bool
+            self
+        end
+    end
+
+    class NthToggle < Toggle
+        def initialize(start_state, max_counter)
+            super start_state
+            @count_max = max_counter
+            @counter = 0
+        end
+
+        def activate
+            @counter += 1
+            if @counter >= @count_max
+                @bool = !@bool
+                @counter = 0
+            end
+            self
+        end
+    end
+
+    n = 1500000 # (ARGV.shift || 1).to_i
+
+    toggle = Toggle.new 1
+    5.times do
+        toggle.activate.value ? 'true' : 'false'
+    end
+    n.times do
+        toggle = Toggle.new 1
+    end
+
+    ntoggle = NthToggle.new 1, 3
+    8.times do
+        ntoggle.activate.value ? 'true' : 'false'
+    end
+    n.times do
+        ntoggle = NthToggle.new 1, 3
+    end
+loop_count: 1
diff --git a/benchmark/so_partial_sums.yml b/benchmark/so_partial_sums.yml
new file mode 100644
index 0000000000..d45017bca8
--- /dev/null
+++ b/benchmark/so_partial_sums.yml
@@ -0,0 +1,34 @@
+benchmark:
+  so_partial_sums: |
+    n = 2_500_000 # (ARGV.shift || 1).to_i
+
+    alt = 1.0 ; s0 = s1 = s2 = s3 = s4 = s5 = s6 = s7 = s8 = 0.0
+
+    1.upto(n) do |d|
+      d = d.to_f ; d2 = d * d ; d3 = d2 * d ; ds = Math.sin(d) ; dc = Math.cos(d)
+
+      s0 += (2.0 / 3.0) ** (d - 1.0)
+      s1 += 1.0 / Math.sqrt(d)
+      s2 += 1.0 / (d * (d + 1.0))
+      s3 += 1.0 / (d3 * ds * ds)
+      s4 += 1.0 / (d3 * dc * dc)
+      s5 += 1.0 / d
+      s6 += 1.0 / d2
+      s7 += alt / d
+      s8 += alt / (2.0 * d - 1.0)
+
+      alt = -alt
+    end
+
+    if false
+      printf("%.9f\t(2/3)^k\n", s0)
+      printf("%.9f\tk^-0.5\n", s1)
+      printf("%.9f\t1/k(k+1)\n", s2)
+      printf("%.9f\tFlint Hills\n", s3)
+      printf("%.9f\tCookson Hills\n", s4)
+      printf("%.9f\tHarmonic\n", s5)
+      printf("%.9f\tRiemann Zeta\n", s6)
+      printf("%.9f\tAlternating Harmonic\n", s7)
+      printf("%.9f\tGregory\n", s8)
+    end
+loop_count: 1
diff --git a/benchmark/so_pidigits.yml b/benchmark/so_pidigits.yml
new file mode 100644
index 0000000000..793745f5b5
--- /dev/null
+++ b/benchmark/so_pidigits.yml
@@ -0,0 +1,95 @@
+prelude: |
+  # The Great Computer Language Shootout
+  # http://shootout.alioth.debian.org/
+benchmark:
+  so_pidigits: |
+    #
+    # contributed by Gabriele Renzi
+
+    class PiDigitSpigot
+
+        def initialize()
+            @z = Transformation.new 1,0,0,1
+            @x = Transformation.new 0,0,0,0
+            @inverse = Transformation.new 0,0,0,0
+        end
+
+        def next!
+            @y = @z.extract(3)
+            if safe? @y
+                @z = produce(@y)
+                @y
+            else
+                @z = consume @x.next!()
+                next!()
+            end
+        end
+
+        def safe?(digit)
+            digit == @z.extract(4)
+        end
+
+        def produce(i)
+            @inverse.qrst(10,-10*i,0,1).compose(@z)
+        end
+
+        def consume(a)
+            @z.compose(a)
+        end
+    end
+
+
+    class Transformation
+        attr_reader :q, :r, :s, :t
+        def initialize(q, r, s, t)
+            @q,@r,@s,@t,@k = q,r,s,t,0
+        end
+
+        def next!()
+            @q = @k = @k + 1
+            @r = 4 * @k + 2
+            @s = 0
+            @t = 2 * @k + 1
+            self
+        end
+
+        def extract(j)
+            (@q * j + @r) / (@s * j + @t)
+        end
+
+        def compose(a)
+            self.class.new( @q * a.q,
+                            @q * a.r + r * a.t,
+                            @s * a.q + t * a.s,
+                            @s * a.r + t * a.t
+                        )
+        end
+
+        def qrst *args
+            initialize *args
+            self
+        end
+
+
+    end
+
+
+    WIDTH = 10
+    n = 2_500 # Integer(ARGV[0])
+    j = 0
+
+    digits = PiDigitSpigot.new
+
+    while n > 0
+        if n >= WIDTH
+            WIDTH.times {print digits.next!}
+            j += WIDTH
+        else
+            n.times {print digits.next!}
+            (WIDTH-n).times {print " "}
+            j += n
+        end
+        puts "\t:"+j.to_s
+        n -= WIDTH
+    end
+loop_count: 1
diff --git a/benchmark/so_random.yml b/benchmark/so_random.yml
new file mode 100644
index 0000000000..3a39453377
--- /dev/null
+++ b/benchmark/so_random.yml
@@ -0,0 +1,24 @@
+prelude: |
+  # from http://www.bagley.org/~doug/shootout/bench/random/random.ruby
+benchmark:
+  so_random: |
+
+    IM = 139968.0
+    IA = 3877.0
+    IC = 29573.0
+
+    $last = 42.0
+
+    def gen_random(max)
+      (max * ($last = ($last * IA + IC) % IM)) / IM
+    end
+
+    N = 3_000_000
+
+    i = 0
+    while i<N
+      i +=1
+      gen_random(100.0)
+    end
+    # "%.9f" % gen_random(100.0)
+loop_count: 1
diff --git a/benchmark/so_sieve.yml b/benchmark/so_sieve.yml
new file mode 100644
index 0000000000..ae90f8f6fb
--- /dev/null
+++ b/benchmark/so_sieve.yml
@@ -0,0 +1,28 @@
+prelude: |
+  # from http://www.bagley.org/~doug/shootout/bench/sieve/sieve.ruby
+benchmark:
+  so_sieve: |
+    num = 500
+    count = i = j = 0
+    flags0 = Array.new(8192,1)
+    k = 0
+    while k < num
+      k += 1
+      count = 0
+      flags = flags0.dup
+      i = 2
+      while i<8192
+        i += 1
+        if flags[i]
+          # remove all multiples of prime: i
+          j = i*i
+          while j < 8192
+            j += i
+            flags[j] = nil
+          end
+          count += 1
+        end
+      end
+    end
+    count
+loop_count: 1
diff --git a/benchmark/so_spectralnorm.yml b/benchmark/so_spectralnorm.yml
new file mode 100644
index 0000000000..45373b6476
--- /dev/null
+++ b/benchmark/so_spectralnorm.yml
@@ -0,0 +1,54 @@
+prelude: |
+  # The Computer Language Shootout
+  # http://shootout.alioth.debian.org/
+  # Contributed by Sokolov Yura
+benchmark:
+  so_spectralnorm: |
+
+    def eval_A(i,j)
+    	return 1.0/((i+j)*(i+j+1)/2+i+1)
+    end
+
+    def eval_A_times_u(u)
+            v, i = nil, nil
+    	(0..u.length-1).collect { |i|
+                    v = 0
+    		for j in 0..u.length-1
+    			v += eval_A(i,j)*u[j]
+                    end
+                    v
+            }
+    end
+
+    def eval_At_times_u(u)
+    	v, i = nil, nil
+    	(0..u.length-1).collect{|i|
+                    v = 0
+    		for j in 0..u.length-1
+    			v += eval_A(j,i)*u[j]
+                    end
+                    v
+            }
+    end
+
+    def eval_AtA_times_u(u)
+    	return eval_At_times_u(eval_A_times_u(u))
+    end
+
+    n = 500 # ARGV[0].to_i
+
+    u=[1]*n
+    for i in 1..10
+            v=eval_AtA_times_u(u)
+            u=eval_AtA_times_u(v)
+    end
+    vBv=0
+    vv=0
+    for i in 0..n-1
+            vBv += u[i]*v[i]
+            vv += v[i]*v[i]
+    end
+
+    str = "%0.9f" % (Math.sqrt(vBv/vv)), "\n"
+    # print str
+loop_count: 1
diff --git a/benchmark/string_index.yml b/benchmark/string_index.yml
new file mode 100644
index 0000000000..f89193a448
--- /dev/null
+++ b/benchmark/string_index.yml
@@ -0,0 +1,6 @@
+benchmark:
+  string_index: |
+    str1 = "あ" * 1024 + "い" # not single byte optimizable
+    str2 = "い"
+    100_000.times { str1.index(str2) }
+loop_count: 1
diff --git a/benchmark/string_scan_re.yml b/benchmark/string_scan_re.yml
new file mode 100644
index 0000000000..a1d249ff52
--- /dev/null
+++ b/benchmark/string_scan_re.yml
@@ -0,0 +1,5 @@
+benchmark:
+  string_scan_re: |
+    str = Array.new(1_000, 'abc').join(',')
+    1_000.times { str.scan(/abc/) }
+loop_count: 1
diff --git a/benchmark/string_scan_str.yml b/benchmark/string_scan_str.yml
new file mode 100644
index 0000000000..3c1bae451a
--- /dev/null
+++ b/benchmark/string_scan_str.yml
@@ -0,0 +1,5 @@
+benchmark:
+  string_scan_str: |
+    str = Array.new(1_000, 'abc').join(',')
+    1_000.times { str.scan('abc') }
+loop_count: 1
diff --git a/benchmark/time_subsec.yml b/benchmark/time_subsec.yml
new file mode 100644
index 0000000000..ee787639c6
--- /dev/null
+++ b/benchmark/time_subsec.yml
@@ -0,0 +1,5 @@
+benchmark:
+  time_subsec: |
+    t = Time.now
+    4000000.times { t.subsec }
+loop_count: 1
diff --git a/benchmark/vm3_backtrace.yml b/benchmark/vm3_backtrace.yml
new file mode 100644
index 0000000000..58df4bc191
--- /dev/null
+++ b/benchmark/vm3_backtrace.yml
@@ -0,0 +1,26 @@
+prelude: |
+  # get last backtrace
+benchmark:
+  vm3_backtrace: |
+
+    begin
+      caller(0, 0)
+    rescue ArgumentError
+      alias caller_orig caller
+      def caller lev, n
+        caller_orig(lev)[0..n]
+      end
+    end
+
+    def rec n
+      if n < 0
+        100_000.times{
+          caller(0, 1)
+        }
+      else
+        rec(n-1)
+      end
+    end
+
+    rec 50
+loop_count: 1
diff --git a/benchmark/vm3_clearmethodcache.yml b/benchmark/vm3_clearmethodcache.yml
new file mode 100644
index 0000000000..63dea7aa58
--- /dev/null
+++ b/benchmark/vm3_clearmethodcache.yml
@@ -0,0 +1,11 @@
+benchmark:
+  vm3_clearmethodcache: |
+    i = 0
+    while i<200_000
+      i += 1
+
+      Class.new{
+        def m; end
+      }
+    end
+loop_count: 1
diff --git a/benchmark/vm3_gc.yml b/benchmark/vm3_gc.yml
new file mode 100644
index 0000000000..5ca177a79a
--- /dev/null
+++ b/benchmark/vm3_gc.yml
@@ -0,0 +1,9 @@
+benchmark:
+  vm3_gc: |
+    5000.times do
+      100.times do
+        {"xxxx"=>"yyyy"}
+      end
+      GC.start
+    end
+loop_count: 1
diff --git a/benchmark/vm3_gc_old_full.yml b/benchmark/vm3_gc_old_full.yml
new file mode 100644
index 0000000000..11958c2d0a
--- /dev/null
+++ b/benchmark/vm3_gc_old_full.yml
@@ -0,0 +1,7 @@
+benchmark:
+  vm3_gc_old_full: |
+    old_object = Array.new(1_000_000){''}
+    100.times do
+      GC.start
+    end
+loop_count: 1
diff --git a/benchmark/vm3_gc_old_immediate.yml b/benchmark/vm3_gc_old_immediate.yml
new file mode 100644
index 0000000000..3aea9c05f9
--- /dev/null
+++ b/benchmark/vm3_gc_old_immediate.yml
@@ -0,0 +1,7 @@
+benchmark:
+  vm3_gc_old_immediate: |
+    old_object = Array.new(1_000_000){''}
+    30_000.times do
+      GC.start(full_mark: false, immediate_sweep: true)
+    end
+loop_count: 1
diff --git a/benchmark/vm3_gc_old_lazy.yml b/benchmark/vm3_gc_old_lazy.yml
new file mode 100644
index 0000000000..37ad5c38f1
--- /dev/null
+++ b/benchmark/vm3_gc_old_lazy.yml
@@ -0,0 +1,7 @@
+benchmark:
+  vm3_gc_old_lazy: |
+    old_object = Array.new(1_000_000){''}
+    30_000.times do
+      GC.start(full_mark: false, immediate_sweep: false)
+    end
+loop_count: 1
diff --git a/benchmark/vm_symbol_block_pass.yml b/benchmark/vm_symbol_block_pass.yml
new file mode 100644
index 0000000000..c690b5944e
--- /dev/null
+++ b/benchmark/vm_symbol_block_pass.yml
@@ -0,0 +1,16 @@
+benchmark:
+  vm_symbol_block_pass: |
+    class C
+      1000.times {|i|
+        eval("def i#{i};end")
+      }
+    end
+
+    c = C.new
+    m = C.instance_methods(false)
+    5_000.times do
+      m.each do |n|
+        c.tap(&n)
+      end
+    end
+loop_count: 1
diff --git a/benchmark/vm_thread_alive_check1.yml b/benchmark/vm_thread_alive_check1.yml
new file mode 100644
index 0000000000..4ab97401da
--- /dev/null
+++ b/benchmark/vm_thread_alive_check1.yml
@@ -0,0 +1,9 @@
+benchmark:
+  vm_thread_alive_check1: |
+    5_000.times{
+      t = Thread.new{}
+      while t.alive?
+        Thread.pass
+      end
+    }
+loop_count: 1
diff --git a/benchmark/vm_thread_close.yml b/benchmark/vm_thread_close.yml
new file mode 100644
index 0000000000..4867f1ca2a
--- /dev/null
+++ b/benchmark/vm_thread_close.yml
@@ -0,0 +1,9 @@
+benchmark:
+  vm_thread_close: |
+    1000.times { Thread.new { sleep } }
+    i = 0
+    while i<100_000 # benchmark loop 3
+      i += 1
+      IO.pipe.each(&:close)
+    end
+loop_count: 1
diff --git a/benchmark/vm_thread_condvar1.yml b/benchmark/vm_thread_condvar1.yml
new file mode 100644
index 0000000000..1f481ab757
--- /dev/null
+++ b/benchmark/vm_thread_condvar1.yml
@@ -0,0 +1,32 @@
+prelude: |
+  # two threads, two mutex, two condvar ping-pong
+benchmark:
+  vm_thread_condvar1: |
+    require 'thread'
+    m1 = Mutex.new
+    m2 = Mutex.new
+    cv1 = ConditionVariable.new
+    cv2 = ConditionVariable.new
+    max = 100000
+    i = 0
+    wait = nil
+    m2.synchronize do
+      wait = Thread.new do
+        m1.synchronize do
+          m2.synchronize { cv2.signal }
+          while (i += 1) < max
+            cv1.wait(m1)
+            cv2.signal
+          end
+        end
+      end
+      cv2.wait(m2)
+    end
+    m1.synchronize do
+      while i < max
+        cv1.signal
+        cv2.wait(m1)
+      end
+    end
+    wait.join
+loop_count: 1
diff --git a/benchmark/vm_thread_condvar2.yml b/benchmark/vm_thread_condvar2.yml
new file mode 100644
index 0000000000..5b5798c7c5
--- /dev/null
+++ b/benchmark/vm_thread_condvar2.yml
@@ -0,0 +1,39 @@
+prelude: |
+  # many threads, one mutex, many condvars
+benchmark:
+  vm_thread_condvar2: |
+    require 'thread'
+    m = Mutex.new
+    cv1 = ConditionVariable.new
+    cv2 = ConditionVariable.new
+    max = 1000
+    n = 100
+    waiting = 0
+    scvs = []
+    waiters = n.times.map do |i|
+      start_cv = ConditionVariable.new
+      scvs << start_cv
+      start_mtx = Mutex.new
+      start_mtx.synchronize do
+        th = Thread.new(start_mtx, start_cv) do |sm, scv|
+          m.synchronize do
+            sm.synchronize { scv.signal }
+            max.times do
+              cv2.signal if (waiting += 1) == n
+              cv1.wait(m)
+            end
+          end
+        end
+        start_cv.wait(start_mtx)
+        th
+      end
+    end
+    m.synchronize do
+      max.times do
+        cv2.wait(m) until waiting == n
+        waiting = 0
+        cv1.broadcast
+      end
+    end
+    waiters.each(&:join)
+loop_count: 1
diff --git a/benchmark/vm_thread_create_join.yml b/benchmark/vm_thread_create_join.yml
new file mode 100644
index 0000000000..7fe82b3fb0
--- /dev/null
+++ b/benchmark/vm_thread_create_join.yml
@@ -0,0 +1,9 @@
+benchmark:
+  vm_thread_create_join: |
+    i = 0
+    while i<100_000 # benchmark loop 3
+      i += 1
+      Thread.new{
+      }.join
+    end
+loop_count: 1
diff --git a/benchmark/vm_thread_mutex1.yml b/benchmark/vm_thread_mutex1.yml
new file mode 100644
index 0000000000..33ab7a2651
--- /dev/null
+++ b/benchmark/vm_thread_mutex1.yml
@@ -0,0 +1,25 @@
+prelude: |
+  # one thread, one mutex (no contention)
+benchmark:
+  vm_thread_mutex1: |
+
+    require 'thread'
+    m = Thread::Mutex.new
+    r = 0
+    max = 2000
+    lmax = max * max
+    (1..1).map{
+      Thread.new{
+        i = 0
+        while i<lmax
+          i += 1
+          m.synchronize{
+            r += 1
+          }
+        end
+      }
+    }.each{|e|
+      e.join
+    }
+    raise r.to_s if r != max * max
+loop_count: 1
diff --git a/benchmark/vm_thread_mutex2.yml b/benchmark/vm_thread_mutex2.yml
new file mode 100644
index 0000000000..e6abe59635
--- /dev/null
+++ b/benchmark/vm_thread_mutex2.yml
@@ -0,0 +1,25 @@
+prelude: |
+  # two threads, one mutex
+benchmark:
+  vm_thread_mutex2: |
+
+    require 'thread'
+    m = Thread::Mutex.new
+    r = 0
+    max = 2000
+    lmax = (max * max)/2
+    (1..2).map{
+      Thread.new{
+        i = 0
+        while i<lmax
+          i += 1
+          m.synchronize{
+            r += 1
+          }
+        end
+      }
+    }.each{|e|
+      e.join
+    }
+    raise r.to_s if r != max * max
+loop_count: 1
diff --git a/benchmark/vm_thread_mutex3.yml b/benchmark/vm_thread_mutex3.yml
new file mode 100644
index 0000000000..99f3b81f99
--- /dev/null
+++ b/benchmark/vm_thread_mutex3.yml
@@ -0,0 +1,24 @@
+prelude: |
+  # 1000 threads, one mutex
+benchmark:
+  vm_thread_mutex3: |
+
+    require 'thread'
+    m = Thread::Mutex.new
+    r = 0
+    max = 2000
+    (1..max).map{
+      Thread.new{
+        i = 0
+        while i<max
+          i += 1
+          m.synchronize{
+            r += 1
+          }
+        end
+      }
+    }.each{|e|
+      e.join
+    }
+    raise r.to_s if r != max * max
+loop_count: 1
diff --git a/benchmark/vm_thread_pass.yml b/benchmark/vm_thread_pass.yml
new file mode 100644
index 0000000000..c5f264ee36
--- /dev/null
+++ b/benchmark/vm_thread_pass.yml
@@ -0,0 +1,17 @@
+prelude: |
+  # Plenty Thtread.pass
+  # A performance may depend on GVL implementation.
+benchmark:
+  vm_thread_pass: |
+
+    tmax = (ARGV.shift || 2).to_i
+    lmax = 200_000 / tmax
+
+    (1..tmax).map{
+      Thread.new{
+        lmax.times{
+          Thread.pass
+        }
+      }
+    }.each{|t| t.join}
+loop_count: 1
diff --git a/benchmark/vm_thread_pass_flood.yml b/benchmark/vm_thread_pass_flood.yml
new file mode 100644
index 0000000000..953288ebe4
--- /dev/null
+++ b/benchmark/vm_thread_pass_flood.yml
@@ -0,0 +1,14 @@
+prelude: |
+  # n.b. this is a good test for GVL when pinned to a single CPU
+benchmark:
+  vm_thread_pass_flood: |
+
+    1000.times{
+      Thread.new{loop{Thread.pass}}
+    }
+
+    i = 0
+    while i<10000
+      i += 1
+    end
+loop_count: 1
diff --git a/benchmark/vm_thread_pipe.yml b/benchmark/vm_thread_pipe.yml
new file mode 100644
index 0000000000..fe4f3b8166
--- /dev/null
+++ b/benchmark/vm_thread_pipe.yml
@@ -0,0 +1,20 @@
+prelude: |
+  # Measure small and plenty pipe read/write.
+  # A performance may depend on GVL implementation.
+benchmark:
+  vm_thread_pipe: |
+
+    lmax = 100_000
+    r, w = IO.pipe
+    [Thread.new{
+      lmax.times{
+        w.write('a')
+      }
+      p "w:exit"
+    }, Thread.new{
+      lmax.times{
+        r.read(1)
+      }
+      p "r:exit"
+    }].each{|t| t.join}
+loop_count: 1
diff --git a/benchmark/vm_thread_queue.yml b/benchmark/vm_thread_queue.yml
new file mode 100644
index 0000000000..1294ad3a13
--- /dev/null
+++ b/benchmark/vm_thread_queue.yml
@@ -0,0 +1,21 @@
+benchmark:
+  vm_thread_queue: |
+    require 'thread'
+
+    n = 1_000_000
+    q = Thread::Queue.new
+    consumer = Thread.new{
+      while q.pop
+        # consuming
+      end
+    }
+
+    producer = Thread.new{
+      n.times{
+        q.push true
+      }
+      q.push nil
+    }
+
+    consumer.join
+loop_count: 1
diff --git a/benchmark/vm_thread_sized_queue.yml b/benchmark/vm_thread_sized_queue.yml
new file mode 100644
index 0000000000..0a79bd4fc1
--- /dev/null
+++ b/benchmark/vm_thread_sized_queue.yml
@@ -0,0 +1,23 @@
+benchmark:
+  vm_thread_sized_queue: |
+    require 'thread'
+    # on producer, one consumer
+
+    n = 1_000_000
+    q = Thread::SizedQueue.new(100)
+    consumer = Thread.new{
+      while q.pop
+        # consuming
+      end
+    }
+
+    producer = Thread.new{
+      while n > 0
+        q.push true
+        n -= 1
+      end
+      q.push nil
+    }
+
+    consumer.join
+loop_count: 1
diff --git a/benchmark/vm_thread_sized_queue2.yml b/benchmark/vm_thread_sized_queue2.yml
new file mode 100644
index 0000000000..7a5c2251c1
--- /dev/null
+++ b/benchmark/vm_thread_sized_queue2.yml
@@ -0,0 +1,26 @@
+benchmark:
+  vm_thread_sized_queue2: |
+    require 'thread'
+    # one producer, many consumers
+    n = 1_000_000
+    m = 10
+    q = Thread::SizedQueue.new(100)
+    consumers = m.times.map do
+      Thread.new do
+        while q.pop
+          # consuming
+        end
+      end
+    end
+
+    producer = Thread.new do
+      while n > 0
+        q.push true
+        n -= 1
+      end
+      m.times { q.push nil }
+    end
+
+    producer.join
+    consumers.each(&:join)
+loop_count: 1
diff --git a/benchmark/vm_thread_sized_queue3.yml b/benchmark/vm_thread_sized_queue3.yml
new file mode 100644
index 0000000000..6eefe50984
--- /dev/null
+++ b/benchmark/vm_thread_sized_queue3.yml
@@ -0,0 +1,25 @@
+benchmark:
+  vm_thread_sized_queue3: |
+    require 'thread'
+    # many producers, one consumer
+    n = 1_000_000
+    m = 10
+    q = Thread::SizedQueue.new(100)
+    consumer = Thread.new do
+      while q.pop
+        # consuming
+      end
+    end
+
+    producers = m.times.map do
+      Thread.new do
+        while n > 0
+          q.push true
+          n -= 1
+        end
+      end
+    end
+    producers.each(&:join)
+    q.push nil
+    consumer.join
+loop_count: 1
diff --git a/benchmark/vm_thread_sized_queue4.yml b/benchmark/vm_thread_sized_queue4.yml
new file mode 100644
index 0000000000..2af8ea4ebe
--- /dev/null
+++ b/benchmark/vm_thread_sized_queue4.yml
@@ -0,0 +1,29 @@
+benchmark:
+  vm_thread_sized_queue4: |
+    require 'thread'
+    # many producers, many consumers
+    nr = 1_000_000
+    n = 10
+    m = 10
+    q = Thread::SizedQueue.new(100)
+    consumers = n.times.map do
+      Thread.new do
+        while q.pop
+          # consuming
+        end
+      end
+    end
+
+    producers = m.times.map do
+      Thread.new do
+        while nr > 0
+          q.push true
+          nr -= 1
+        end
+      end
+    end
+
+    producers.each(&:join)
+    n.times { q.push nil }
+    consumers.each(&:join)
+loop_count: 1