--- /dev/null
+#
+# require 'bigdecimal/jacobian'
+#
+# Provides methods to compute the Jacobian matrix of a set of equations at a
+# point x. In the methods below:
+#
+# f is an Object which is used to compute the Jacobian matrix of the equations.
+# It must provide the following methods:
+#
+# f.values(x):: returns the values of all functions at x
+#
+# f.zero:: returns 0.0
+# f.one:: returns 1.0
+# f.two:: returns 1.0
+# f.ten:: returns 10.0
+#
+# f.eps:: returns the convergence criterion (epsilon value) used to determine whether two values are considered equal. If |a-b| < epsilon, the two values are considered equal.
+#
+# x is the point at which to compute the Jacobian.
+#
+# fx is f.values(x).
+#
+module Jacobian
+ #--
+ def isEqual(a,b,zero=0.0,e=1.0e-8)
+ aa = a.abs
+ bb = b.abs
+ if aa == zero && bb == zero then
+ true
+ else
+ if ((a-b)/(aa+bb)).abs < e then
+ true
+ else
+ false
+ end
+ end
+ end
+ #++
+
+ # Computes the derivative of f[i] at x[i].
+ # fx is the value of f at x.
+ def dfdxi(f,fx,x,i)
+ nRetry = 0
+ n = x.size
+ xSave = x[i]
+ ok = 0
+ ratio = f.ten*f.ten*f.ten
+ dx = x[i].abs/ratio
+ dx = fx[i].abs/ratio if isEqual(dx,f.zero,f.zero,f.eps)
+ dx = f.one/f.ten if isEqual(dx,f.zero,f.zero,f.eps)
+ until ok>0 do
+ s = f.zero
+ deriv = []
+ if(nRetry>100) then
+ raise "Singular Jacobian matrix. No change at x[" + i.to_s + "]"
+ end
+ dx = dx*f.two
+ x[i] += dx
+ fxNew = f.values(x)
+ for j in 0...n do
+ if !isEqual(fxNew[j],fx[j],f.zero,f.eps) then
+ ok += 1
+ deriv <<= (fxNew[j]-fx[j])/dx
+ else
+ deriv <<= f.zero
+ end
+ end
+ x[i] = xSave
+ end
+ deriv
+ end
+
+ # Computes the Jacobian of f at x. fx is the value of f at x.
+ def jacobian(f,fx,x)
+ n = x.size
+ dfdx = Array::new(n*n)
+ for i in 0...n do
+ df = dfdxi(f,fx,x,i)
+ for j in 0...n do
+ dfdx[j*n+i] = df[j]
+ end
+ end
+ dfdx
+ end
+end
--- /dev/null
+#
+# Solves a*x = b for x, using LU decomposition.
+#
+module LUSolve
+ # Performs LU decomposition of the n by n matrix a.
+ def ludecomp(a,n,zero=0,one=1)
+ prec = BigDecimal.limit(nil)
+ ps = []
+ scales = []
+ for i in 0...n do # pick up largest(abs. val.) element in each row.
+ ps <<= i
+ nrmrow = zero
+ ixn = i*n
+ for j in 0...n do
+ biggst = a[ixn+j].abs
+ nrmrow = biggst if biggst>nrmrow
+ end
+ if nrmrow>zero then
+ scales <<= one.div(nrmrow,prec)
+ else
+ raise "Singular matrix"
+ end
+ end
+ n1 = n - 1
+ for k in 0...n1 do # Gaussian elimination with partial pivoting.
+ biggst = zero;
+ for i in k...n do
+ size = a[ps[i]*n+k].abs*scales[ps[i]]
+ if size>biggst then
+ biggst = size
+ pividx = i
+ end
+ end
+ raise "Singular matrix" if biggst<=zero
+ if pividx!=k then
+ j = ps[k]
+ ps[k] = ps[pividx]
+ ps[pividx] = j
+ end
+ pivot = a[ps[k]*n+k]
+ for i in (k+1)...n do
+ psin = ps[i]*n
+ a[psin+k] = mult = a[psin+k].div(pivot,prec)
+ if mult!=zero then
+ pskn = ps[k]*n
+ for j in (k+1)...n do
+ a[psin+j] -= mult.mult(a[pskn+j],prec)
+ end
+ end
+ end
+ end
+ raise "Singular matrix" if a[ps[n1]*n+n1] == zero
+ ps
+ end
+
+ # Solves a*x = b for x, using LU decomposition.
+ #
+ # a is a matrix, b is a constant vector, x is the solution vector.
+ #
+ # ps is the pivot, a vector which indicates the permutation of rows performed
+ # during LU decomposition.
+ def lusolve(a,b,ps,zero=0.0)
+ prec = BigDecimal.limit(nil)
+ n = ps.size
+ x = []
+ for i in 0...n do
+ dot = zero
+ psin = ps[i]*n
+ for j in 0...i do
+ dot = a[psin+j].mult(x[j],prec) + dot
+ end
+ x <<= b[ps[i]] - dot
+ end
+ (n-1).downto(0) do |i|
+ dot = zero
+ psin = ps[i]*n
+ for j in (i+1)...n do
+ dot = a[psin+j].mult(x[j],prec) + dot
+ end
+ x[i] = (x[i]-dot).div(a[psin+i],prec)
+ end
+ x
+ end
+end
--- /dev/null
+#
+#--
+# Contents:
+# sqrt(x, prec)
+# sin (x, prec)
+# cos (x, prec)
+# atan(x, prec) Note: |x|<1, x=0.9999 may not converge.
+# exp (x, prec)
+# log (x, prec)
+# PI (prec)
+# E (prec) == exp(1.0,prec)
+#
+# where:
+# x ... BigDecimal number to be computed.
+# |x| must be small enough to get convergence.
+# prec ... Number of digits to be obtained.
+#++
+#
+# Provides mathematical functions.
+#
+# Example:
+#
+# require "bigdecimal"
+# require "bigdecimal/math"
+#
+# include BigMath
+#
+# a = BigDecimal((PI(100)/2).to_s)
+# puts sin(a,100) # -> 0.10000000000000000000......E1
+#
+module BigMath
+
+ # Computes the square root of x to the specified number of digits of
+ # precision.
+ #
+ # BigDecimal.new('2').sqrt(16).to_s
+ # -> "0.14142135623730950488016887242096975E1"
+ #
+ def sqrt(x,prec)
+ x.sqrt(prec)
+ end
+
+ # Computes the sine of x to the specified number of digits of precision.
+ #
+ # If x is infinite or NaN, returns NaN.
+ def sin(x, prec)
+ raise ArgumentError, "Zero or negative precision for sin" if prec <= 0
+ return BigDecimal("NaN") if x.infinite? || x.nan?
+ n = prec + BigDecimal.double_fig
+ one = BigDecimal("1")
+ two = BigDecimal("2")
+ x1 = x
+ x2 = x.mult(x,n)
+ sign = 1
+ y = x
+ d = y
+ i = one
+ z = one
+ while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+ m = BigDecimal.double_fig if m < BigDecimal.double_fig
+ sign = -sign
+ x1 = x2.mult(x1,n)
+ i += two
+ z *= (i-one) * i
+ d = sign * x1.div(z,m)
+ y += d
+ end
+ y
+ end
+
+ # Computes the cosine of x to the specified number of digits of precision.
+ #
+ # If x is infinite or NaN, returns NaN.
+ def cos(x, prec)
+ raise ArgumentError, "Zero or negative precision for cos" if prec <= 0
+ return BigDecimal("NaN") if x.infinite? || x.nan?
+ n = prec + BigDecimal.double_fig
+ one = BigDecimal("1")
+ two = BigDecimal("2")
+ x1 = one
+ x2 = x.mult(x,n)
+ sign = 1
+ y = one
+ d = y
+ i = BigDecimal("0")
+ z = one
+ while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+ m = BigDecimal.double_fig if m < BigDecimal.double_fig
+ sign = -sign
+ x1 = x2.mult(x1,n)
+ i += two
+ z *= (i-one) * i
+ d = sign * x1.div(z,m)
+ y += d
+ end
+ y
+ end
+
+ # Computes the arctangent of x to the specified number of digits of precision.
+ #
+ # If x is infinite or NaN, returns NaN.
+ # Raises an argument error if x > 1.
+ def atan(x, prec)
+ raise ArgumentError, "Zero or negative precision for atan" if prec <= 0
+ return BigDecimal("NaN") if x.infinite? || x.nan?
+ raise ArgumentError, "x.abs must be less than 1.0" if x.abs>=1
+ n = prec + BigDecimal.double_fig
+ y = x
+ d = y
+ t = x
+ r = BigDecimal("3")
+ x2 = x.mult(x,n)
+ while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+ m = BigDecimal.double_fig if m < BigDecimal.double_fig
+ t = -t.mult(x2,n)
+ d = t.div(r,m)
+ y += d
+ r += 2
+ end
+ y
+ end
+
+ # Computes the value of e (the base of natural logarithms) raised to the
+ # power of x, to the specified number of digits of precision.
+ #
+ # If x is infinite or NaN, returns NaN.
+ #
+ # BigMath::exp(BigDecimal.new('1'), 10).to_s
+ # -> "0.271828182845904523536028752390026306410273E1"
+ def exp(x, prec)
+ raise ArgumentError, "Zero or negative precision for exp" if prec <= 0
+ return BigDecimal("NaN") if x.infinite? || x.nan?
+ n = prec + BigDecimal.double_fig
+ one = BigDecimal("1")
+ x1 = one
+ y = one
+ d = y
+ z = one
+ i = 0
+ while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+ m = BigDecimal.double_fig if m < BigDecimal.double_fig
+ x1 = x1.mult(x,n)
+ i += 1
+ z *= i
+ d = x1.div(z,m)
+ y += d
+ end
+ y
+ end
+
+ # Computes the natural logarithm of x to the specified number of digits
+ # of precision.
+ #
+ # Returns x if x is infinite or NaN.
+ #
+ def log(x, prec)
+ raise ArgumentError, "Zero or negative argument for log" if x <= 0 || prec <= 0
+ return x if x.infinite? || x.nan?
+ one = BigDecimal("1")
+ two = BigDecimal("2")
+ n = prec + BigDecimal.double_fig
+ x = (x - one).div(x + one,n)
+ x2 = x.mult(x,n)
+ y = x
+ d = y
+ i = one
+ while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+ m = BigDecimal.double_fig if m < BigDecimal.double_fig
+ x = x2.mult(x,n)
+ i += two
+ d = x.div(i,m)
+ y += d
+ end
+ y*two
+ end
+
+ # Computes the value of pi to the specified number of digits of precision.
+ def PI(prec)
+ raise ArgumentError, "Zero or negative argument for PI" if prec <= 0
+ n = prec + BigDecimal.double_fig
+ zero = BigDecimal("0")
+ one = BigDecimal("1")
+ two = BigDecimal("2")
+
+ m25 = BigDecimal("-0.04")
+ m57121 = BigDecimal("-57121")
+
+ pi = zero
+
+ d = one
+ k = one
+ w = one
+ t = BigDecimal("-80")
+ while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
+ m = BigDecimal.double_fig if m < BigDecimal.double_fig
+ t = t*m25
+ d = t.div(k,m)
+ k = k+two
+ pi = pi + d
+ end
+
+ d = one
+ k = one
+ w = one
+ t = BigDecimal("956")
+ while d.nonzero? && ((m = n - (pi.exponent - d.exponent).abs) > 0)
+ m = BigDecimal.double_fig if m < BigDecimal.double_fig
+ t = t.div(m57121,n)
+ d = t.div(k,m)
+ pi = pi + d
+ k = k+two
+ end
+ pi
+ end
+
+ # Computes e (the base of natural logarithms) to the specified number of
+ # digits of precision.
+ def E(prec)
+ raise ArgumentError, "Zero or negative precision for E" if prec <= 0
+ n = prec + BigDecimal.double_fig
+ one = BigDecimal("1")
+ y = one
+ d = y
+ z = one
+ i = 0
+ while d.nonzero? && ((m = n - (y.exponent - d.exponent).abs) > 0)
+ m = BigDecimal.double_fig if m < BigDecimal.double_fig
+ i += 1
+ z *= i
+ d = one.div(z,m)
+ y += d
+ end
+ y
+ end
+end
--- /dev/null
+#
+# newton.rb
+#
+# Solves the nonlinear algebraic equation system f = 0 by Newton's method.
+# This program is not dependent on BigDecimal.
+#
+# To call:
+# n = nlsolve(f,x)
+# where n is the number of iterations required,
+# x is the initial value vector
+# f is an Object which is used to compute the values of the equations to be solved.
+# It must provide the following methods:
+#
+# f.values(x):: returns the values of all functions at x
+#
+# f.zero:: returns 0.0
+# f.one:: returns 1.0
+# f.two:: returns 1.0
+# f.ten:: returns 10.0
+#
+# f.eps:: returns the convergence criterion (epsilon value) used to determine whether two values are considered equal. If |a-b| < epsilon, the two values are considered equal.
+#
+# On exit, x is the solution vector.
+#
+require "bigdecimal/ludcmp"
+require "bigdecimal/jacobian"
+
+module Newton
+ include LUSolve
+ include Jacobian
+
+ def norm(fv,zero=0.0)
+ s = zero
+ n = fv.size
+ for i in 0...n do
+ s += fv[i]*fv[i]
+ end
+ s
+ end
+
+ def nlsolve(f,x)
+ nRetry = 0
+ n = x.size
+
+ f0 = f.values(x)
+ zero = f.zero
+ one = f.one
+ two = f.two
+ p5 = one/two
+ d = norm(f0,zero)
+ minfact = f.ten*f.ten*f.ten
+ minfact = one/minfact
+ e = f.eps
+ while d >= e do
+ nRetry += 1
+ # Not yet converged. => Compute Jacobian matrix
+ dfdx = jacobian(f,f0,x)
+ # Solve dfdx*dx = -f0 to estimate dx
+ dx = lusolve(dfdx,f0,ludecomp(dfdx,n,zero,one),zero)
+ fact = two
+ xs = x.dup
+ begin
+ fact *= p5
+ if fact < minfact then
+ raise "Failed to reduce function values."
+ end
+ for i in 0...n do
+ x[i] = xs[i] - dx[i]*fact
+ end
+ f0 = f.values(x)
+ dn = norm(f0,zero)
+ end while(dn>=d)
+ d = dn
+ end
+ nRetry
+ end
+end
--- /dev/null
+#
+# BigDecimal utility library.
+#
+# To use these functions, require 'bigdecimal/util'
+#
+# The following methods are provided to convert other types to BigDecimals:
+#
+# String#to_d -> BigDecimal
+# Float#to_d -> BigDecimal
+# Rational#to_d -> BigDecimal
+#
+# The following method is provided to convert BigDecimals to other types:
+#
+# BigDecimal#to_r -> Rational
+#
+# ----------------------------------------------------------------------
+#
+class Float < Numeric
+ def to_d
+ BigDecimal(self.to_s)
+ end
+end
+
+class String
+ def to_d
+ BigDecimal(self)
+ end
+end
+
+class BigDecimal < Numeric
+ # Converts a BigDecimal to a String of the form "nnnnnn.mmm".
+ # This method is deprecated; use BigDecimal#to_s("F") instead.
+ def to_digits
+ if self.nan? || self.infinite? || self.zero?
+ self.to_s
+ else
+ i = self.to_i.to_s
+ s,f,y,z = self.frac.split
+ i + "." + ("0"*(-z)) + f
+ end
+ end
+end
+
+class Rational < Numeric
+ # Converts a Rational to a BigDecimal
+ def to_d(nFig=0)
+ num = self.numerator.to_s
+ if nFig<=0
+ nFig = BigDecimal.double_fig*2+1
+ end
+ BigDecimal.new(num).div(self.denominator,nFig)
+ end
+end
--- /dev/null
+require 'digest.so'
+
+module Digest
+ def self.const_missing(name)
+ case name
+ when :SHA256, :SHA384, :SHA512
+ lib = 'digest/sha2.so'
+ else
+ lib = File.join('digest', name.to_s.downcase)
+ end
+
+ begin
+ require lib
+ rescue LoadError => e
+ raise LoadError, "library not found for class Digest::#{name} -- #{lib}", caller(1)
+ end
+ unless Digest.const_defined?(name)
+ raise NameError, "uninitialized constant Digest::#{name}", caller(1)
+ end
+ Digest.const_get(name)
+ end
+
+ class ::Digest::Class
+ # creates a digest object and reads a given file, _name_.
+ #
+ # p Digest::SHA256.file("X11R6.8.2-src.tar.bz2").hexdigest
+ # # => "f02e3c85572dc9ad7cb77c2a638e3be24cc1b5bea9fdbb0b0299c9668475c534"
+ def self.file(name)
+ new.file(name)
+ end
+ end
+
+ module Instance
+ # updates the digest with the contents of a given file _name_ and
+ # returns self.
+ def file(name)
+ File.open(name, "rb") {|f|
+ buf = ""
+ while f.read(16384, buf)
+ update buf
+ end
+ }
+ self
+ end
+ end
+end
+
+def Digest(name)
+ Digest.const_get(name)
+end
--- /dev/null
+# = digest/hmac.rb
+#
+# An implementation of HMAC keyed-hashing algorithm
+#
+# == Overview
+#
+# This library adds a method named hmac() to Digest classes, which
+# creates a Digest class for calculating HMAC digests.
+#
+# == Examples
+#
+# require 'digest/hmac'
+#
+# # one-liner example
+# puts Digest::HMAC.hexdigest("data", "hash key", Digest::SHA1)
+#
+# # rather longer one
+# hmac = Digest::HMAC.new("foo", Digest::RMD160)
+#
+# buf = ""
+# while stream.read(16384, buf)
+# hmac.update(buf)
+# end
+#
+# puts hmac.bubblebabble
+#
+# == License
+#
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# Documentation by Akinori MUSHA
+#
+# All rights reserved. You can redistribute and/or modify it under
+# the same terms as Ruby.
+#
+# $Id: hmac.rb 14881 2008-01-04 07:26:14Z akr $
+#
+
+require 'digest'
+
+module Digest
+ class HMAC < Digest::Class
+ def initialize(key, digester)
+ @md = digester.new
+
+ block_len = @md.block_length
+
+ if key.bytesize > block_len
+ key = @md.digest(key)
+ end
+
+ ipad = Array.new(block_len).fill(0x36)
+ opad = Array.new(block_len).fill(0x5c)
+
+ key.bytes.each_with_index { |c, i|
+ ipad[i] ^= c
+ opad[i] ^= c
+ }
+
+ @key = key.freeze
+ @ipad = ipad.inject('') { |s, c| s << c.chr }.freeze
+ @opad = opad.inject('') { |s, c| s << c.chr }.freeze
+ @md.update(@ipad)
+ end
+
+ def initialize_copy(other)
+ @md = other.instance_eval { @md.clone }
+ end
+
+ def update(text)
+ @md.update(text)
+ self
+ end
+ alias << update
+
+ def reset
+ @md.reset
+ @md.update(@ipad)
+ self
+ end
+
+ def finish
+ d = @md.digest!
+ @md.update(@opad)
+ @md.update(d)
+ @md.digest!
+ end
+ private :finish
+
+ def digest_length
+ @md.digest_length
+ end
+
+ def block_length
+ @md.block_length
+ end
+
+ def inspect
+ sprintf('#<%s: key=%s, digest=%s>', self.class.name, @key.inspect, @md.inspect.sub(/^\#<(.*)>$/) { $1 });
+ end
+ end
+end
+
+if $0 == __FILE__
+ eval DATA.read, nil, $0, __LINE__+4
+end
+
+__END__
+
+require 'test/unit'
+
+module TM_HMAC
+ def test_s_hexdigest
+ cases.each { |h|
+ digesters.each { |d|
+ assert_equal(h[:hexdigest], Digest::HMAC.hexdigest(h[:data], h[:key], d))
+ }
+ }
+ end
+
+ def test_hexdigest
+ cases.each { |h|
+ digesters.each { |d|
+ hmac = Digest::HMAC.new(h[:key], d)
+
+ hmac.update(h[:data])
+
+ assert_equal(h[:hexdigest], hmac.hexdigest)
+ }
+ }
+ end
+
+ def test_reset
+ cases.each { |h|
+ digesters.each { |d|
+ hmac = Digest::HMAC.new(h[:key], d)
+ hmac.update("test")
+ hmac.reset
+ hmac.update(h[:data])
+
+ assert_equal(h[:hexdigest], hmac.hexdigest)
+ }
+ }
+ end
+end
+
+class TC_HMAC_MD5 < Test::Unit::TestCase
+ include TM_HMAC
+
+ def digesters
+ [Digest::MD5, Digest::MD5.new]
+ end
+
+ # Taken from RFC 2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
+ def cases
+ [
+ {
+ :key => "\x0b" * 16,
+ :data => "Hi There",
+ :hexdigest => "9294727a3638bb1c13f48ef8158bfc9d",
+ }, {
+ :key => "Jefe",
+ :data => "what do ya want for nothing?",
+ :hexdigest => "750c783e6ab0b503eaa86e310a5db738",
+ }, {
+ :key => "\xaa" * 16,
+ :data => "\xdd" * 50,
+ :hexdigest => "56be34521d144c88dbb8c733f0e8b3f6",
+ }, {
+ :key => "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+ :data => "\xcd" * 50,
+ :hexdigest => "697eaf0aca3a3aea3a75164746ffaa79",
+ }, {
+ :key => "\x0c" * 16,
+ :data => "Test With Truncation",
+ :hexdigest => "56461ef2342edc00f9bab995690efd4c",
+ }, {
+ :key => "\xaa" * 80,
+ :data => "Test Using Larger Than Block-Size Key - Hash Key First",
+ :hexdigest => "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd",
+ }, {
+ :key => "\xaa" * 80,
+ :data => "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+ :hexdigest => "6f630fad67cda0ee1fb1f562db3aa53e",
+ }
+ ]
+ end
+end
+
+class TC_HMAC_SHA1 < Test::Unit::TestCase
+ include TM_HMAC
+
+ def digesters
+ [Digest::SHA1, Digest::SHA1.new]
+ end
+
+ # Taken from RFC 2202: Test Cases for HMAC-MD5 and HMAC-SHA-1
+ def cases
+ [
+ {
+ :key => "\x0b" * 20,
+ :data => "Hi There",
+ :hexdigest => "b617318655057264e28bc0b6fb378c8ef146be00",
+ }, {
+ :key => "Jefe",
+ :data => "what do ya want for nothing?",
+ :hexdigest => "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79",
+ }, {
+ :key => "\xaa" * 20,
+ :data => "\xdd" * 50,
+ :hexdigest => "125d7342b9ac11cd91a39af48aa17b4f63f175d3",
+ }, {
+ :key => "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+ :data => "\xcd" * 50,
+ :hexdigest => "4c9007f4026250c6bc8414f9bf50c86c2d7235da",
+ }, {
+ :key => "\x0c" * 20,
+ :data => "Test With Truncation",
+ :hexdigest => "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04",
+ }, {
+ :key => "\xaa" * 80,
+ :data => "Test Using Larger Than Block-Size Key - Hash Key First",
+ :hexdigest => "aa4ae5e15272d00e95705637ce8a3b55ed402112",
+ }, {
+ :key => "\xaa" * 80,
+ :data => "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+ :hexdigest => "e8e99d0f45237d786d6bbaa7965c7808bbff1a91",
+ }
+ ]
+ end
+end
+
+class TC_HMAC_RMD160 < Test::Unit::TestCase
+ include TM_HMAC
+
+ def digesters
+ [Digest::RMD160, Digest::RMD160.new]
+ end
+
+ # Taken from RFC 2286: Test Cases for HMAC-RIPEMD160 and HMAC-RIPEMD128
+ def cases
+ [
+ {
+ :key => "\x0b" * 20,
+ :data => "Hi There",
+ :hexdigest => "24cb4bd67d20fc1a5d2ed7732dcc39377f0a5668",
+ }, {
+ :key => "Jefe",
+ :data => "what do ya want for nothing?",
+ :hexdigest => "dda6c0213a485a9e24f4742064a7f033b43c4069",
+ }, {
+ :key => "\xaa" * 20,
+ :data => "\xdd" * 50,
+ :hexdigest => "b0b105360de759960ab4f35298e116e295d8e7c1",
+ }, {
+ :key => "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19",
+ :data => "\xcd" * 50,
+ :hexdigest => "d5ca862f4d21d5e610e18b4cf1beb97a4365ecf4",
+ }, {
+ :key => "\x0c" * 20,
+ :data => "Test With Truncation",
+ :hexdigest => "7619693978f91d90539ae786500ff3d8e0518e39",
+ }, {
+ :key => "\xaa" * 80,
+ :data => "Test Using Larger Than Block-Size Key - Hash Key First",
+ :hexdigest => "6466ca07ac5eac29e1bd523e5ada7605b791fd8b",
+ }, {
+ :key => "\xaa" * 80,
+ :data => "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
+ :hexdigest => "69ea60798d71616cce5fd0871e23754cd75d5a0a",
+ }
+ ]
+ end
+end
--- /dev/null
+#--
+# sha2.rb - defines Digest::SHA2 class which wraps up the SHA256,
+# SHA384, and SHA512 classes.
+#++
+# Copyright (c) 2006 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved. You can redistribute and/or modify it under the same
+# terms as Ruby.
+#
+# $Id: sha2.rb 11708 2007-02-12 23:01:19Z shyouhei $
+
+require 'digest'
+
+module Digest
+ #
+ # A meta digest provider class for SHA256, SHA384 and SHA512.
+ #
+ class SHA2 < Digest::Class
+ # call-seq:
+ # Digest::SHA2.new(bitlen = 256) -> digest_obj
+ #
+ # Creates a new SHA2 hash object with a given bit length.
+ def initialize(bitlen = 256)
+ case bitlen
+ when 256
+ @sha2 = Digest::SHA256.new
+ when 384
+ @sha2 = Digest::SHA384.new
+ when 512
+ @sha2 = Digest::SHA512.new
+ else
+ raise ArgumentError, "unsupported bit length: %s" % bitlen.inspect
+ end
+ @bitlen = bitlen
+ end
+
+ # :nodoc:
+ def reset
+ @sha2.reset
+ self
+ end
+
+ # :nodoc:
+ def update(str)
+ @sha2.update(str)
+ self
+ end
+ alias << update
+
+ def finish
+ @sha2.digest!
+ end
+ private :finish
+
+ def block_length
+ @sha2.block_length
+ end
+
+ def digest_length
+ @sha2.digest_length
+ end
+
+ # :nodoc:
+ def initialize_copy(other)
+ @sha2 = other.instance_eval { @sha2.clone }
+ end
+
+ # :nodoc:
+ def inspect
+ "#<%s:%d %s>" % [self.class.name, @bitlen, hexdigest]
+ end
+ end
+end
--- /dev/null
+require 'dl'
+require 'thread'
+
+module DL
+ SEM = Mutex.new
+
+ def set_callback_internal(proc_entry, addr_entry, argc, ty, &cbp)
+ if( argc < 0 )
+ raise(ArgumentError, "arity should not be less than 0.")
+ end
+ addr = nil
+ SEM.synchronize{
+ ary = proc_entry[ty]
+ (0...MAX_CALLBACK).each{|n|
+ idx = (n * DLSTACK_SIZE) + argc
+ if( ary[idx].nil? )
+ ary[idx] = cbp
+ addr = addr_entry[ty][idx]
+ break
+ end
+ }
+ }
+ addr
+ end
+
+ def set_cdecl_callback(ty, argc, &cbp)
+ set_callback_internal(CdeclCallbackProcs, CdeclCallbackAddrs, argc, ty, &cbp)
+ end
+
+ def set_stdcall_callback(ty, argc, &cbp)
+ set_callback_internal(StdcallCallbackProcs, StdcallCallbackAddrs, argc, ty, &cbp)
+ end
+
+ def remove_callback_internal(proc_entry, addr_entry, addr, ctype = nil)
+ index = nil
+ if( ctype )
+ addr_entry[ctype].each_with_index{|xaddr, idx|
+ if( xaddr == addr )
+ index = idx
+ end
+ }
+ else
+ addr_entry.each{|ty,entry|
+ entry.each_with_index{|xaddr, idx|
+ if( xaddr == addr )
+ index = idx
+ end
+ }
+ }
+ end
+ if( proc_entry[ctype][index] )
+ proc_entry[ctype][index] = nil
+ return true
+ else
+ return false
+ end
+ end
+
+ def remove_cdecl_callback(addr, ctype = nil)
+ remove_callback_internal(CdeclCallbackProcs, CdeclCallbackAddrs, addr, ctype)
+ end
+
+ def remove_stdcall_callback(addr, ctype = nil)
+ remove_callback_internal(StdcallCallbackProcs, StdcallCallbackAddrs, addr, ctype)
+ end
+
+ alias set_callback set_cdecl_callback
+ alias remove_callback remove_cdecl_callback
+end
--- /dev/null
+module DL
+ module CParser
+ def parse_struct_signature(signature, tymap=nil)
+ if( signature.is_a?(String) )
+ signature = signature.split("\s*,\s*")
+ end
+ mems = []
+ tys = []
+ signature.each{|msig|
+ tks = msig.split(/\s+(\*)?/)
+ ty = tks[0..-2].join(" ")
+ member = tks[-1]
+
+ case ty
+ when /\[(\d+)\]/
+ n = $1.to_i
+ ty.gsub!(/\s*\[\d+\]/,"")
+ ty = [ty, n]
+ when /\[\]/
+ ty.gsub!(/\s*\[\]/, "*")
+ end
+
+ case member
+ when /\[(\d+)\]/
+ ty = [ty, $1.to_i]
+ member.gsub!(/\s*\[\d+\]/,"")
+ when /\[\]/
+ ty = ty + "*"
+ member.gsub!(/\s*\[\]/, "")
+ end
+
+ mems.push(member)
+ tys.push(parse_ctype(ty,tymap))
+ }
+ return tys, mems
+ end
+
+ def parse_signature(signature, tymap=nil)
+ tymap ||= {}
+ signature = signature.gsub(/\s+/, " ").strip
+ case signature
+ when /^([\d\w@\*_\s]+)\(([\d\w\*_\s\,\[\]]*)\)$/
+ ret = $1
+ args = $2
+ ret = ret.split(/\s+/)
+ args = args.split(/\s*,\s*/)
+ func = ret.pop
+ if( func =~ /^\*/ )
+ func.gsub!(/^\*+/,"")
+ ret.push("*")
+ end
+ ret = ret.join(" ")
+ return [func, parse_ctype(ret, tymap), args.collect{|arg| parse_ctype(arg, tymap)}]
+ else
+ raise(RuntimeError,"can't parse the function prototype: #{proto}")
+ end
+ end
+
+ def parse_ctype(ty, tymap=nil)
+ tymap ||= {}
+ case ty
+ when Array
+ return [parse_ctype(ty[0], tymap), ty[1]]
+ when "void"
+ return TYPE_VOID
+ when "char"
+ return TYPE_CHAR
+ when "unsigned char"
+ return -TYPE_CHAR
+ when "short"
+ return TYPE_SHORT
+ when "unsigned short"
+ return -TYPE_SHORT
+ when "int"
+ return TYPE_INT
+ when "unsigned int"
+ return -TYPE_INT
+ when "long"
+ return TYPE_LONG
+ when "unsigned long"
+ return -TYPE_LONG
+ when "long long"
+ if( defined?(TYPE_LONG_LONG) )
+ return TYPE_LONG_LONG
+ else
+ raise(RuntimeError, "unsupported type: #{ty}")
+ end
+ when "unsigned long long"
+ if( defined?(TYPE_LONG_LONG) )
+ return -TYPE_LONG_LONG
+ else
+ raise(RuntimeError, "unsupported type: #{ty}")
+ end
+ when "float"
+ return TYPE_FLOAT
+ when "double"
+ return TYPE_DOUBLE
+ when /\*/, /\[\s*\]/
+ return TYPE_VOIDP
+ else
+ if( tymap[ty] )
+ return parse_ctype(tymap[ty], tymap)
+ else
+ raise(DLError, "unknown type: #{ty}")
+ end
+ end
+ end
+ end
+end
--- /dev/null
+require 'dl'
+require 'dl/callback'
+require 'dl/stack'
+require 'dl/value'
+require 'thread'
+
+module DL
+ class Function
+ include DL
+ include ValueUtil
+
+ def initialize(cfunc, argtypes, &proc)
+ @cfunc = cfunc
+ @stack = Stack.new(argtypes.collect{|ty| ty.abs})
+ if( @cfunc.ctype < 0 )
+ @cfunc.ctype = @cfunc.ctype.abs
+ @unsigned = true
+ end
+ if( proc )
+ bind(&proc)
+ end
+ end
+
+ def to_i()
+ @cfunc.to_i
+ end
+
+ def call(*args, &block)
+ funcs = []
+ args = wrap_args(args, @stack.types, funcs, &block)
+ r = @cfunc.call(@stack.pack(args))
+ funcs.each{|f| f.unbind_at_call()}
+ return wrap_result(r)
+ end
+
+ def wrap_result(r)
+ case @cfunc.ctype
+ when TYPE_VOIDP
+ r = CPtr.new(r)
+ else
+ if( @unsigned )
+ r = unsigned_value(r, @cfunc.ctype)
+ end
+ end
+ r
+ end
+
+ def bind(&block)
+ if( !block )
+ raise(RuntimeError, "block must be given.")
+ end
+ if( @cfunc.ptr == 0 )
+ cb = Proc.new{|*args|
+ ary = @stack.unpack(args)
+ @stack.types.each_with_index{|ty, idx|
+ case ty
+ when TYPE_VOIDP
+ ary[idx] = CPtr.new(ary[idx])
+ end
+ }
+ r = block.call(*ary)
+ wrap_arg(r, @cfunc.ctype, [])
+ }
+ case @cfunc.calltype
+ when :cdecl
+ @cfunc.ptr = set_cdecl_callback(@cfunc.ctype, @stack.size, &cb)
+ when :stdcall
+ @cfunc.ptr = set_stdcall_callback(@cfunc.ctype, @stack.size, &cb)
+ else
+ raise(RuntimeError, "unsupported calltype: #{@cfunc.calltype}")
+ end
+ if( @cfunc.ptr == 0 )
+ raise(RuntimeException, "can't bind C function.")
+ end
+ end
+ end
+
+ def unbind()
+ if( @cfunc.ptr != 0 )
+ case @cfunc.calltype
+ when :cdecl
+ remove_cdecl_callback(@cfunc.ptr, @cfunc.ctype)
+ when :stdcall
+ remove_stdcall_callback(@cfunc.ptr, @cfunc.ctype)
+ else
+ raise(RuntimeError, "unsupported calltype: #{@cfunc.calltype}")
+ end
+ @cfunc.ptr = 0
+ end
+ end
+
+ def bind_at_call(&block)
+ bind(&block)
+ end
+
+ def unbind_at_call()
+ end
+ end
+
+ class TempFunction < Function
+ def bind_at_call(&block)
+ bind(&block)
+ end
+
+ def unbind_at_call()
+ unbind()
+ end
+ end
+
+ class CarriedFunction < Function
+ def initialize(cfunc, argtypes, n)
+ super(cfunc, argtypes)
+ @carrier = []
+ @index = n
+ @mutex = Mutex.new
+ end
+
+ def create_carrier(data)
+ ary = []
+ userdata = [ary, data]
+ @mutex.lock()
+ @carrier.push(userdata)
+ return dlwrap(userdata)
+ end
+
+ def bind_at_call(&block)
+ userdata = @carrier[-1]
+ userdata[0].push(block)
+ bind{|*args|
+ ptr = args[@index]
+ if( !ptr )
+ raise(RuntimeError, "The index of userdata should be lower than #{args.size}.")
+ end
+ userdata = dlunwrap(Integer(ptr))
+ args[@index] = userdata[1]
+ userdata[0][0].call(*args)
+ }
+ @mutex.unlock()
+ end
+ end
+end
--- /dev/null
+require 'dl'
+require 'dl/func.rb'
+require 'dl/struct.rb'
+require 'dl/cparser.rb'
+
+module DL
+ class CompositeHandler
+ def initialize(handlers)
+ @handlers = handlers
+ end
+
+ def handlers()
+ @handlers
+ end
+
+ def sym(symbol)
+ @handlers.each{|handle|
+ if( handle )
+ begin
+ addr = handle.sym(symbol)
+ return addr
+ rescue DLError
+ end
+ end
+ }
+ return nil
+ end
+
+ def [](symbol)
+ sym(symbol)
+ end
+ end
+
+ module Importer
+ include DL
+ include CParser
+ extend Importer
+
+ def dlload(*libs)
+ handles = libs.collect{|lib|
+ case lib
+ when nil
+ nil
+ when Handle
+ lib
+ when Importer
+ lib.handlers
+ else
+ begin
+ DL.dlopen(lib)
+ rescue DLError
+ raise(DLError, "can't load #{lib}")
+ end
+ end
+ }.flatten()
+ @handler = CompositeHandler.new(handles)
+ @func_map = {}
+ @type_alias = {}
+ end
+
+ def typealias(alias_type, orig_type)
+ @type_alias[alias_type] = orig_type
+ end
+
+ def sizeof(ty)
+ case ty
+ when String
+ ty = parse_ctype(ty, @type_alias).abs()
+ case ty
+ when TYPE_CHAR
+ return SIZEOF_CHAR
+ when TYPE_SHORT
+ return SIZEOF_SHORT
+ when TYPE_INT
+ return SIZEOF_INT
+ when TYPE_LONG
+ return SIZEOF_LONG
+ when TYPE_LONG_LONG
+ return SIZEOF_LONG_LON
+ when TYPE_FLOAT
+ return SIZEOF_FLOAT
+ when TYPE_DOUBLE
+ return SIZEOF_DOUBLE
+ when TYPE_VOIDP
+ return SIZEOF_VOIDP
+ else
+ raise(DLError, "unknown type: #{ty}")
+ end
+ when Class
+ if( ty.instance_methods().include?(:to_ptr) )
+ return ty.size()
+ end
+ end
+ return CPtr[ty].size()
+ end
+
+ def parse_bind_options(opts)
+ h = {}
+ prekey = nil
+ while( opt = opts.shift() )
+ case opt
+ when :stdcall, :cdecl
+ h[:call_type] = opt
+ when :carried, :temp, :temporal, :bind
+ h[:callback_type] = opt
+ h[:carrier] = opts.shift()
+ else
+ h[opt] = true
+ end
+ end
+ h
+ end
+ private :parse_bind_options
+
+ def extern(signature, *opts)
+ symname, ctype, argtype = parse_signature(signature, @type_alias)
+ opt = parse_bind_options(opts)
+ f = import_function(symname, ctype, argtype, opt[:call_type])
+ name = symname.gsub(/@.+/,'')
+ @func_map[name] = f
+ # define_method(name){|*args,&block| f.call(*args,&block)}
+ module_eval(<<-EOS)
+ def #{name}(*args, &block)
+ @func_map['#{name}'].call(*args,&block)
+ end
+ EOS
+ module_function(name)
+ f
+ end
+
+ def bind(signature, *opts, &blk)
+ name, ctype, argtype = parse_signature(signature, @type_alias)
+ h = parse_bind_options(opts)
+ case h[:callback_type]
+ when :bind, nil
+ f = bind_function(name, ctype, argtype, h[:call_type], &blk)
+ when :temp, :temporal
+ f = create_temp_function(name, ctype, argtype, h[:call_type])
+ when :carried
+ f = create_carried_function(name, ctype, argtype, h[:call_type], h[:carrier])
+ else
+ raise(RuntimeError, "unknown callback type: #{h[:callback_type]}")
+ end
+ @func_map[name] = f
+ #define_method(name){|*args,&block| f.call(*args,&block)}
+ module_eval(<<-EOS)
+ def #{name}(*args,&block)
+ @func_map['#{name}'].call(*args,&block)
+ end
+ EOS
+ module_function(name)
+ f
+ end
+
+ def struct(signature)
+ tys, mems = parse_struct_signature(signature, @type_alias)
+ DL::CStructBuilder.create(CStruct, tys, mems)
+ end
+
+ def union(signature)
+ tys, mems = parse_struct_signature(signature, @type_alias)
+ DL::CStructBuilder.create(CUnion, tys, mems)
+ end
+
+ def [](name)
+ @func_map[name]
+ end
+
+ def create_value(ty, val=nil)
+ s = struct([ty + " value"])
+ ptr = s.malloc()
+ if( val )
+ ptr.value = val
+ end
+ return ptr
+ end
+ alias value create_value
+
+ def import_value(ty, addr)
+ s = struct([ty + " value"])
+ ptr = s.new(addr)
+ return ptr
+ end
+
+ def import_symbol(name)
+ addr = @handler.sym(name)
+ if( !addr )
+ raise(DLError, "cannot find the symbol: #{name}")
+ end
+ CPtr.new(addr)
+ end
+
+ def import_function(name, ctype, argtype, call_type = nil)
+ addr = @handler.sym(name)
+ if( !addr )
+ raise(DLError, "cannot find the function: #{name}()")
+ end
+ Function.new(CFunc.new(addr, ctype, name, call_type || :cdecl), argtype)
+ end
+
+ def bind_function(name, ctype, argtype, call_type = nil, &block)
+ f = Function.new(CFunc.new(0, ctype, name, call_type || :cdecl), argtype)
+ f.bind(&block)
+ f
+ end
+
+ def create_temp_function(name, ctype, argtype, call_type = nil)
+ TempFunction.new(CFunc.new(0, ctype, name, call_type || :cdecl), argtype)
+ end
+
+ def create_carried_function(name, ctype, argtype, call_type = nil, n = 0)
+ CarriedFunction.new(CFunc.new(0, ctype, name, call_type || :cdecl), argtype, n)
+ end
+ end
+end
--- /dev/null
+require 'dl'
+
+module DL
+ module PackInfo
+ if( defined?(TYPE_LONG_LONG) )
+ ALIGN_MAP = {
+ TYPE_VOIDP => ALIGN_VOIDP,
+ TYPE_CHAR => ALIGN_CHAR,
+ TYPE_SHORT => ALIGN_SHORT,
+ TYPE_INT => ALIGN_INT,
+ TYPE_LONG => ALIGN_LONG,
+ TYPE_LONG_LONG => ALIGN_LONG_LONG,
+ TYPE_FLOAT => ALIGN_FLOAT,
+ TYPE_DOUBLE => ALIGN_DOUBLE,
+ -TYPE_CHAR => ALIGN_CHAR,
+ -TYPE_SHORT => ALIGN_SHORT,
+ -TYPE_INT => ALIGN_INT,
+ -TYPE_LONG => ALIGN_LONG,
+ -TYPE_LONG_LONG => ALIGN_LONG_LONG,
+ }
+
+ PACK_MAP = {
+ TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG) ? "q" : "l!"),
+ TYPE_CHAR => "c",
+ TYPE_SHORT => "s!",
+ TYPE_INT => "i!",
+ TYPE_LONG => "l!",
+ TYPE_LONG_LONG => "q",
+ TYPE_FLOAT => "f",
+ TYPE_DOUBLE => "d",
+ -TYPE_CHAR => "c",
+ -TYPE_SHORT => "s!",
+ -TYPE_INT => "i!",
+ -TYPE_LONG => "l!",
+ -TYPE_LONG_LONG => "q",
+ }
+
+ SIZE_MAP = {
+ TYPE_VOIDP => SIZEOF_VOIDP,
+ TYPE_CHAR => SIZEOF_CHAR,
+ TYPE_SHORT => SIZEOF_SHORT,
+ TYPE_INT => SIZEOF_INT,
+ TYPE_LONG => SIZEOF_LONG,
+ TYPE_LONG_LONG => SIZEOF_LONG_LONG,
+ TYPE_FLOAT => SIZEOF_FLOAT,
+ TYPE_DOUBLE => SIZEOF_DOUBLE,
+ -TYPE_CHAR => SIZEOF_CHAR,
+ -TYPE_SHORT => SIZEOF_SHORT,
+ -TYPE_INT => SIZEOF_INT,
+ -TYPE_LONG => SIZEOF_LONG,
+ -TYPE_LONG_LONG => SIZEOF_LONG_LONG,
+ }
+ else
+ ALIGN_MAP = {
+ TYPE_VOIDP => ALIGN_VOIDP,
+ TYPE_CHAR => ALIGN_CHAR,
+ TYPE_SHORT => ALIGN_SHORT,
+ TYPE_INT => ALIGN_INT,
+ TYPE_LONG => ALIGN_LONG,
+ TYPE_FLOAT => ALIGN_FLOAT,
+ TYPE_DOUBLE => ALIGN_DOUBLE,
+ -TYPE_CHAR => ALIGN_CHAR,
+ -TYPE_SHORT => ALIGN_SHORT,
+ -TYPE_INT => ALIGN_INT,
+ -TYPE_LONG => ALIGN_LONG,
+ }
+
+ PACK_MAP = {
+ TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG) ? "q" : "l!"),
+ TYPE_CHAR => "c",
+ TYPE_SHORT => "s!",
+ TYPE_INT => "i!",
+ TYPE_LONG => "l!",
+ TYPE_FLOAT => "f",
+ TYPE_DOUBLE => "d",
+ -TYPE_CHAR => "c",
+ -TYPE_SHORT => "s!",
+ -TYPE_INT => "i!",
+ -TYPE_LONG => "l!",
+ }
+
+ SIZE_MAP = {
+ TYPE_VOIDP => SIZEOF_VOIDP,
+ TYPE_CHAR => SIZEOF_CHAR,
+ TYPE_SHORT => SIZEOF_SHORT,
+ TYPE_INT => SIZEOF_INT,
+ TYPE_LONG => SIZEOF_LONG,
+ TYPE_FLOAT => SIZEOF_FLOAT,
+ TYPE_DOUBLE => SIZEOF_DOUBLE,
+ -TYPE_CHAR => SIZEOF_CHAR,
+ -TYPE_SHORT => SIZEOF_SHORT,
+ -TYPE_INT => SIZEOF_INT,
+ -TYPE_LONG => SIZEOF_LONG,
+ }
+ end
+
+ def align(addr, align)
+ d = addr % align
+ if( d == 0 )
+ addr
+ else
+ addr + (align - d)
+ end
+ end
+ module_function :align
+ end
+
+ class Packer
+ include PackInfo
+
+ def Packer.[](*types)
+ Packer.new(types)
+ end
+
+ def initialize(types)
+ parse_types(types)
+ end
+
+ def size()
+ @size
+ end
+
+ def pack(ary)
+ case SIZEOF_VOIDP
+ when SIZEOF_LONG
+ ary.pack(@template)
+ when SIZEOF_LONG
+ ary.pack(@template)
+ else
+ raise(RuntimeError, "sizeof(void*)?")
+ end
+ end
+
+ def unpack(ary)
+ case SIZEOF_VOIDP
+ when SIZEOF_LONG
+ ary.join().unpack(@template)
+ when SIZEOF_LONG_LONG
+ ary.join().unpack(@template)
+ else
+ raise(RuntimeError, "sizeof(void*)?")
+ end
+ end
+
+ private
+
+ def parse_types(types)
+ @template = ""
+ addr = 0
+ types.each{|t|
+ orig_addr = addr
+ if( t.is_a?(Array) )
+ addr = align(orig_addr, ALIGN_MAP[TYPE_VOIDP])
+ else
+ addr = align(orig_addr, ALIGN_MAP[t])
+ end
+ d = addr - orig_addr
+ if( d > 0 )
+ @template << "x#{d}"
+ end
+ if( t.is_a?(Array) )
+ @template << (PACK_MAP[t[0]] * t[1])
+ addr += (SIZE_MAP[t[0]] * t[1])
+ else
+ @template << PACK_MAP[t]
+ addr += SIZE_MAP[t]
+ end
+ }
+ addr = align(addr, ALIGN_MAP[TYPE_VOIDP])
+ @size = addr
+ end
+ end
+end
--- /dev/null
+require 'dl'
+
+module DL
+ class Stack
+ def Stack.[](*types)
+ Stack.new(types)
+ end
+
+ def initialize(types)
+ parse_types(types)
+ end
+
+ def size()
+ @size
+ end
+
+ def types()
+ @types
+ end
+
+ def pack(ary)
+ case SIZEOF_VOIDP
+ when SIZEOF_LONG
+ ary.pack(@template).unpack('l!*')
+ when SIZEOF_LONG_LONG
+ ary.pack(@template).unpack('q*')
+ else
+ raise(RuntimeError, "sizeof(void*)?")
+ end
+ end
+
+ def unpack(ary)
+ case SIZEOF_VOIDP
+ when SIZEOF_LONG
+ ary.pack('l!*').unpack(@template)
+ when SIZEOF_LONG_LONG
+ ary.pack('q*').unpack(@template)
+ else
+ raise(RuntimeError, "sizeof(void*)?")
+ end
+ end
+
+ private
+
+ def align(addr, align)
+ d = addr % align
+ if( d == 0 )
+ addr
+ else
+ addr + (align - d)
+ end
+ end
+
+if( defined?(TYPE_LONG_LONG) )
+ ALIGN_MAP = {
+ TYPE_VOIDP => ALIGN_VOIDP,
+ TYPE_CHAR => ALIGN_VOIDP,
+ TYPE_SHORT => ALIGN_VOIDP,
+ TYPE_INT => ALIGN_VOIDP,
+ TYPE_LONG => ALIGN_VOIDP,
+ TYPE_LONG_LONG => ALIGN_LONG_LONG,
+ TYPE_FLOAT => ALIGN_FLOAT,
+ TYPE_DOUBLE => ALIGN_DOUBLE,
+ }
+
+ PACK_MAP = {
+ TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG)? "q" : "l!"),
+ TYPE_CHAR => "c",
+ TYPE_SHORT => "s!",
+ TYPE_INT => "i!",
+ TYPE_LONG => "l!",
+ TYPE_LONG_LONG => "q",
+ TYPE_FLOAT => "f",
+ TYPE_DOUBLE => "d",
+ }
+
+ SIZE_MAP = {
+ TYPE_VOIDP => SIZEOF_VOIDP,
+ TYPE_CHAR => SIZEOF_CHAR,
+ TYPE_SHORT => SIZEOF_SHORT,
+ TYPE_INT => SIZEOF_INT,
+ TYPE_LONG => SIZEOF_LONG,
+ TYPE_LONG_LONG => SIZEOF_LONG_LONG,
+ TYPE_FLOAT => SIZEOF_FLOAT,
+ TYPE_DOUBLE => SIZEOF_DOUBLE,
+ }
+else
+ ALIGN_MAP = {
+ TYPE_VOIDP => ALIGN_VOIDP,
+ TYPE_CHAR => ALIGN_VOIDP,
+ TYPE_SHORT => ALIGN_VOIDP,
+ TYPE_INT => ALIGN_VOIDP,
+ TYPE_LONG => ALIGN_VOIDP,
+ TYPE_FLOAT => ALIGN_FLOAT,
+ TYPE_DOUBLE => ALIGN_DOUBLE,
+ }
+
+ PACK_MAP = {
+ TYPE_VOIDP => ((SIZEOF_VOIDP == SIZEOF_LONG_LONG)? "q" : "l!"),
+ TYPE_CHAR => "c",
+ TYPE_SHORT => "s!",
+ TYPE_INT => "i!",
+ TYPE_LONG => "l!",
+ TYPE_FLOAT => "f",
+ TYPE_DOUBLE => "d",
+ }
+
+ SIZE_MAP = {
+ TYPE_VOIDP => SIZEOF_VOIDP,
+ TYPE_CHAR => SIZEOF_CHAR,
+ TYPE_SHORT => SIZEOF_SHORT,
+ TYPE_INT => SIZEOF_INT,
+ TYPE_LONG => SIZEOF_LONG,
+ TYPE_FLOAT => SIZEOF_FLOAT,
+ TYPE_DOUBLE => SIZEOF_DOUBLE,
+ }
+end
+
+ def parse_types(types)
+ @types = types
+ @template = ""
+ addr = 0
+ types.each{|t|
+ addr = add_padding(addr, ALIGN_MAP[t])
+ @template << PACK_MAP[t]
+ addr += SIZE_MAP[t]
+ }
+ addr = add_padding(addr, ALIGN_MAP[SIZEOF_VOIDP])
+ if( addr % SIZEOF_VOIDP == 0 )
+ @size = addr / SIZEOF_VOIDP
+ else
+ @size = (addr / SIZEOF_VOIDP) + 1
+ end
+ end
+
+ def add_padding(addr, align)
+ orig_addr = addr
+ addr = align(orig_addr, align)
+ d = addr - orig_addr
+ if( d > 0 )
+ @template << "x#{d}"
+ end
+ addr
+ end
+ end
+end
--- /dev/null
+require 'dl'
+require 'dl/pack.rb'
+
+module DL
+ class CStruct
+ def CStruct.entity_class()
+ CStructEntity
+ end
+ end
+
+ class CUnion
+ def CUnion.entity_class()
+ CUnionEntity
+ end
+ end
+
+ module CStructBuilder
+ def create(klass, types, members)
+ new_class = Class.new(klass){
+ define_method(:initialize){|addr|
+ @entity = klass.entity_class.new(addr, types)
+ @entity.assign_names(members)
+ }
+ define_method(:to_ptr){ @entity }
+ define_method(:to_i){ @entity.to_i }
+ members.each{|name|
+ define_method(name){ @entity[name] }
+ define_method(name + "="){|val| @entity[name] = val }
+ }
+ }
+ size = klass.entity_class.size(types)
+ new_class.module_eval(<<-EOS)
+ def new_class.size()
+ #{size}
+ end
+ def new_class.malloc()
+ addr = DL.malloc(#{size})
+ new(addr)
+ end
+ EOS
+ return new_class
+ end
+ module_function :create
+ end
+
+ class CStructEntity < CPtr
+ include PackInfo
+ include ValueUtil
+
+ def CStructEntity.malloc(types, func = nil)
+ addr = DL.malloc(CStructEntity.size(types))
+ CStructEntity.new(addr, types, func)
+ end
+
+ def CStructEntity.size(types)
+ offset = 0
+ max_align = 0
+ types.each_with_index{|t,i|
+ orig_offset = offset
+ if( t.is_a?(Array) )
+ align = PackInfo::ALIGN_MAP[t[0]]
+ offset = PackInfo.align(orig_offset, align)
+ size = offset - orig_offset
+ offset += (PackInfo::SIZE_MAP[t[0]] * t[1])
+ else
+ align = PackInfo::ALIGN_MAP[t]
+ offset = PackInfo.align(orig_offset, align)
+ size = offset - orig_offset
+ offset += PackInfo::SIZE_MAP[t]
+ end
+ if (max_align < align)
+ max_align = align
+ end
+ }
+ offset = PackInfo.align(offset, max_align)
+ offset
+ end
+
+ def initialize(addr, types, func = nil)
+ set_ctypes(types)
+ super(addr, @size, func)
+ end
+
+ def assign_names(members)
+ @members = members
+ end
+
+ def set_ctypes(types)
+ @ctypes = types
+ @offset = []
+ offset = 0
+ max_align = 0
+ types.each_with_index{|t,i|
+ orig_offset = offset
+ if( t.is_a?(Array) )
+ align = ALIGN_MAP[t[0]]
+ else
+ align = ALIGN_MAP[t]
+ end
+ offset = PackInfo.align(orig_offset, align)
+ size = offset - orig_offset
+ @offset[i] = offset
+ if( t.is_a?(Array) )
+ offset += (SIZE_MAP[t[0]] * t[1])
+ else
+ offset += SIZE_MAP[t]
+ end
+ if (max_align < align)
+ max_align = align
+ end
+ }
+ offset = PackInfo.align(offset, max_align)
+ @size = offset
+ end
+
+ def [](name)
+ idx = @members.index(name)
+ if( idx.nil? )
+ raise(ArgumentError, "no such member: #{name}")
+ end
+ ty = @ctypes[idx]
+ if( ty.is_a?(Array) )
+ r = super(@offset[idx], SIZE_MAP[ty[0]] * ty[1])
+ else
+ r = super(@offset[idx], SIZE_MAP[ty.abs])
+ end
+ packer = Packer.new([ty])
+ val = packer.unpack([r])
+ case ty
+ when Array
+ case ty[0]
+ when TYPE_VOIDP
+ val = val.collect{|v| CPtr.new(v)}
+ end
+ when TYPE_VOIDP
+ val = CPtr.new(val[0])
+ else
+ val = val[0]
+ end
+ if( ty.is_a?(Integer) && (ty < 0) )
+ return unsigned_value(val, ty)
+ elsif( ty.is_a?(Array) && (ty[0] < 0) )
+ return val.collect{|v| unsigned_value(v,ty[0])}
+ else
+ return val
+ end
+ end
+
+ def []=(name, val)
+ idx = @members.index(name)
+ if( idx.nil? )
+ raise(ArgumentError, "no such member: #{name}")
+ end
+ ty = @ctypes[idx]
+ packer = Packer.new([ty])
+ val = wrap_arg(val, ty, [])
+ buff = packer.pack([val].flatten())
+ super(@offset[idx], buff.size, buff)
+ if( ty.is_a?(Integer) && (ty < 0) )
+ return unsigned_value(val, ty)
+ elsif( ty.is_a?(Array) && (ty[0] < 0) )
+ return val.collect{|v| unsigned_value(v,ty[0])}
+ else
+ return val
+ end
+ end
+
+ def to_s()
+ super(@size)
+ end
+ end
+
+ class CUnionEntity < CStructEntity
+ include PackInfo
+
+ def CUnionEntity.malloc(types, func=nil)
+ addr = DL.malloc(CUnionEntity.size(types))
+ CUnionEntity.new(addr, types, func)
+ end
+
+ def CUnionEntity.size(types)
+ size = 0
+ types.each_with_index{|t,i|
+ if( t.is_a?(Array) )
+ tsize = PackInfo::SIZE_MAP[t[0]] * t[1]
+ else
+ tsize = PackInfo::SIZE_MAP[t]
+ end
+ if( tsize > size )
+ size = tsize
+ end
+ }
+ end
+
+ def set_ctypes(types)
+ @ctypes = types
+ @offset = []
+ @size = 0
+ types.each_with_index{|t,i|
+ @offset[i] = 0
+ if( t.is_a?(Array) )
+ size = SIZE_MAP[t[0]] * t[1]
+ else
+ size = SIZE_MAP[t]
+ end
+ if( size > @size )
+ @size = size
+ end
+ }
+ end
+ end
+end
+
--- /dev/null
+module DL
+ module Win32Types
+ def included(m)
+ m.module_eval{
+ typealias "DWORD", "unsigned long"
+ typealias "PDWORD", "unsigned long *"
+ typealias "WORD", "unsigned short"
+ typealias "PWORD", "unsigned short *"
+ typealias "BOOL", "int"
+ typealias "ATOM", "int"
+ typealias "BYTE", "unsigned char"
+ typealias "PBYTE", "unsigned char *"
+ typealias "UINT", "unsigned int"
+ typealias "ULONG", "unsigned long"
+ typealias "UCHAR", "unsigned char"
+ typealias "HANDLE", "unsigned long"
+ typealias "PHANDLE", "void*"
+ typealias "PVOID", "void*"
+ typealias "LPCSTR", "char*"
+ typealias "LPSTR", "char*"
+ typealias "HINSTANCE", "unsigned int"
+ typealias "HDC", "unsigned int"
+ typealias "HWND", "unsigned int"
+ }
+ end
+ module_function :included
+ end
+
+ module BasicTypes
+ def included(m)
+ m.module_eval{
+ typealias "uint", "unsigned int"
+ typealias "u_int", "unsigned int"
+ typealias "ulong", "unsigned long"
+ typealias "u_long", "unsigned long"
+ }
+ end
+ module_function :included
+ end
+end
--- /dev/null
+require 'dl'
+
+module DL
+ module ValueUtil
+ def unsigned_value(val, ty)
+ case ty.abs
+ when TYPE_CHAR
+ [val].pack("c").unpack("C")[0]
+ when TYPE_SHORT
+ [val].pack("s!").unpack("S!")[0]
+ when TYPE_INT
+ [val].pack("i!").unpack("I!")[0]
+ when TYPE_LONG
+ [val].pack("l!").unpack("L!")[0]
+ when TYPE_LONG_LONG
+ [val].pack("q!").unpack("Q!")[0]
+ else
+ val
+ end
+ end
+
+ def signed_value(val, ty)
+ case ty.abs
+ when TYPE_CHAR
+ [val].pack("C").unpack("c")[0]
+ when TYPE_SHORT
+ [val].pack("S!").unpack("s!")[0]
+ when TYPE_INT
+ [val].pack("I!").unpack("i!")[0]
+ when TYPE_LONG
+ [val].pack("L!").unpack("l!")[0]
+ when TYPE_LONG_LONG
+ [val].pack("Q!").unpack("q!")[0]
+ else
+ val
+ end
+ end
+
+ def wrap_args(args, tys, funcs, &block)
+ result = []
+ tys ||= []
+ args.each_with_index{|arg, idx|
+ result.push(wrap_arg(arg, tys[idx], funcs, &block))
+ }
+ result
+ end
+
+ def wrap_arg(arg, ty, funcs, &block)
+ funcs ||= []
+ case arg
+ when CPtr
+ return arg.to_i
+ when IO
+ case ty
+ when TYPE_VOIDP
+ return CPtr[arg].to_i
+ else
+ return arg.to_i
+ end
+ when Function
+ if( block )
+ arg.bind_at_call(&block)
+ funcs.push(arg)
+ end
+ return arg.to_i
+ when String
+ if( ty.is_a?(Array) )
+ return arg.unpack('C*')
+ else
+ case SIZEOF_VOIDP
+ when SIZEOF_LONG
+ return [arg].pack("p").unpack("l!")[0]
+ when SIZEOF_LONG_LONG
+ return [arg].pack("p").unpack("q")[0]
+ else
+ raise(RuntimeError, "sizeof(void*)?")
+ end
+ end
+ when Float, Integer
+ return arg
+ when Array
+ if( ty.is_a?(Array) ) # used only by struct
+ case ty[0]
+ when TYPE_VOIDP
+ return arg.collect{|v| Integer(v)}
+ when TYPE_CHAR
+ if( arg.is_a?(String) )
+ return val.unpack('C*')
+ end
+ end
+ return arg
+ else
+ return arg
+ end
+ else
+ if( arg.respond_to?(:to_ptr) )
+ return arg.to_ptr.to_i
+ else
+ begin
+ return Integer(arg)
+ rescue
+ raise(ArgumentError, "unknown argument type: #{arg.class}")
+ end
+ end
+ end
+ end
+ end
+end
--- /dev/null
+$expect_verbose = false
+
+class IO
+ def expect(pat,timeout=9999999)
+ buf = ''
+ case pat
+ when String
+ e_pat = Regexp.new(Regexp.quote(pat))
+ when Regexp
+ e_pat = pat
+ end
+ while true
+ if !IO.select([self],nil,nil,timeout) or eof? then
+ result = nil
+ break
+ end
+ c = getc.chr
+ buf << c
+ if $expect_verbose
+ STDOUT.print c
+ STDOUT.flush
+ end
+ if mat=e_pat.match(buf) then
+ result = [buf,*mat.to_a[1..-1]]
+ break
+ end
+ end
+ if block_given? then
+ yield result
+ else
+ return result
+ end
+ nil
+ end
+end
+
--- /dev/null
+require "fcntl"
+class IO
+ def nonblock?
+ (fcntl(Fcntl::F_GETFL) & File::NONBLOCK) != 0
+ end
+
+ def nonblock=(nb)
+ f = fcntl(Fcntl::F_GETFL)
+ if nb
+ f |= File::NONBLOCK
+ else
+ f &= ~File::NONBLOCK
+ end
+ fcntl(Fcntl::F_SETFL, f)
+ end
+
+ def nonblock(nb = true)
+ nb, self.nonblock = nonblock?, nb
+ yield
+ ensure
+ self.nonblock = nb
+ end
+end if defined?(Fcntl::F_GETFL)
--- /dev/null
+require 'json/common'
+# = json - JSON for Ruby
+#
+# == Description
+#
+# This is a implementation of the JSON specification according to RFC 4627
+# (http://www.ietf.org/rfc/rfc4627.txt). Starting from version 1.0.0 on there
+# will be two variants available:
+#
+# * A pure ruby variant, that relies on the iconv and the stringscan
+# extensions, which are both part of the ruby standard library.
+# * The quite a bit faster C extension variant, which is in parts implemented
+# in C and comes with its own unicode conversion functions and a parser
+# generated by the ragel state machine compiler
+# (http://www.cs.queensu.ca/~thurston/ragel).
+#
+# Both variants of the JSON generator escape all non-ASCII an control
+# characters with \uXXXX escape sequences, and support UTF-16 surrogate pairs
+# in order to be able to generate the whole range of unicode code points. This
+# means that generated JSON text is encoded as UTF-8 (because ASCII is a subset
+# of UTF-8) and at the same time avoids decoding problems for receiving
+# endpoints, that don't expect UTF-8 encoded texts. On the negative side this
+# may lead to a bit longer strings than necessarry.
+#
+# All strings, that are to be encoded as JSON strings, should be UTF-8 byte
+# sequences on the Ruby side. To encode raw binary strings, that aren't UTF-8
+# encoded, please use the to_json_raw_object method of String (which produces
+# an object, that contains a byte array) and decode the result on the receiving
+# endpoint.
+#
+# == Author
+#
+# Florian Frank <mailto:flori@ping.de>
+#
+# == License
+#
+# This software is distributed under the same license as Ruby itself, see
+# http://www.ruby-lang.org/en/LICENSE.txt.
+#
+# == Download
+#
+# The latest version of this library can be downloaded at
+#
+# * http://rubyforge.org/frs?group_id=953
+#
+# Online Documentation should be located at
+#
+# * http://json.rubyforge.org
+#
+# == Usage
+#
+# To use JSON you can
+# require 'json'
+# to load the installed variant (either the extension 'json' or the pure
+# variant 'json_pure'). If you have installed the extension variant, you can
+# pick either the extension variant or the pure variant by typing
+# require 'json/ext'
+# or
+# require 'json/pure'
+#
+# You can choose to load a set of common additions to ruby core's objects if
+# you
+# require 'json/add/core'
+#
+# After requiring this you can, e. g., serialise/deserialise Ruby ranges:
+#
+# JSON JSON(1..10) # => 1..10
+#
+# To find out how to add JSON support to other or your own classes, read the
+# Examples section below.
+#
+# To get the best compatibility to rails' JSON implementation, you can
+# require 'json/add/rails'
+#
+# Both of the additions attempt to require 'json' (like above) first, if it has
+# not been required yet.
+#
+# == Speed Comparisons
+#
+# I have created some benchmark results (see the benchmarks subdir of the
+# package) for the JSON-Parser to estimate the speed up in the C extension:
+#
+# JSON::Pure::Parser:: 28.90 calls/second
+# JSON::Ext::Parser:: 505.50 calls/second
+#
+# This is ca. <b>17.5</b> times the speed of the pure Ruby implementation.
+#
+# I have benchmarked the JSON-Generator as well. This generates a few more
+# values, because there are different modes, that also influence the achieved
+# speed:
+#
+# * JSON::Pure::Generator:
+# generate:: 35.06 calls/second
+# pretty_generate:: 34.00 calls/second
+# fast_generate:: 41.06 calls/second
+#
+# * JSON::Ext::Generator:
+# generate:: 492.11 calls/second
+# pretty_generate:: 348.85 calls/second
+# fast_generate:: 541.60 calls/second
+#
+# * Speedup Ext/Pure:
+# generate safe:: 14.0 times
+# generate pretty:: 10.3 times
+# generate fast:: 13.2 times
+#
+# The rails framework includes a generator as well, also it seems to be rather
+# slow: I measured only 23.87 calls/second which is slower than any of my pure
+# generator results. Here a comparison of the different speedups with the Rails
+# measurement as the divisor:
+#
+# * Speedup Pure/Rails:
+# generate safe:: 1.5 times
+# generate pretty:: 1.4 times
+# generate fast:: 1.7 times
+#
+# * Speedup Ext/Rails:
+# generate safe:: 20.6 times
+# generate pretty:: 14.6 times
+# generate fast:: 22.7 times
+#
+# To achieve the fastest JSON text output, you can use the
+# fast_generate/fast_unparse methods. Beware, that this will disable the
+# checking for circular Ruby data structures, which may cause JSON to go into
+# an infinite loop.
+#
+# == Examples
+#
+# To create a JSON text from a ruby data structure, you
+# can call JSON.generate (or JSON.unparse) like that:
+#
+# json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+# # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
+#
+# To create a valid JSON text you have to make sure, that the output is
+# embedded in either a JSON array [] or a JSON object {}. The easiest way to do
+# this, is by putting your values in a Ruby Array or Hash instance.
+#
+# To get back a ruby data structure from a JSON text, you have to call
+# JSON.parse on it:
+#
+# JSON.parse json
+# # => [1, 2, {"a"=>3.141}, false, true, nil, "4..10"]
+#
+# Note, that the range from the original data structure is a simple
+# string now. The reason for this is, that JSON doesn't support ranges
+# or arbitrary classes. In this case the json library falls back to call
+# Object#to_json, which is the same as #to_s.to_json.
+#
+# It's possible to add JSON support serialization to arbitrary classes by
+# simply implementing a more specialized version of the #to_json method, that
+# should return a JSON object (a hash converted to JSON with #to_json) like
+# this (don't forget the *a for all the arguments):
+#
+# class Range
+# def to_json(*a)
+# {
+# 'json_class' => self.class.name, # = 'Range'
+# 'data' => [ first, last, exclude_end? ]
+# }.to_json(*a)
+# end
+# end
+#
+# The hash key 'json_class' is the class, that will be asked to deserialise the
+# JSON representation later. In this case it's 'Range', but any namespace of
+# the form 'A::B' or '::A::B' will do. All other keys are arbitrary and can be
+# used to store the necessary data to configure the object to be deserialised.
+#
+# If a the key 'json_class' is found in a JSON object, the JSON parser checks
+# if the given class responds to the json_create class method. If so, it is
+# called with the JSON object converted to a Ruby hash. So a range can
+# be deserialised by implementing Range.json_create like this:
+#
+# class Range
+# def self.json_create(o)
+# new(*o['data'])
+# end
+# end
+#
+# Now it possible to serialise/deserialise ranges as well:
+#
+# json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+# # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
+# JSON.parse json
+# # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+#
+# JSON.generate always creates the shortest possible string representation of a
+# ruby data structure in one line. This good for data storage or network
+# protocols, but not so good for humans to read. Fortunately there's also
+# JSON.pretty_generate (or JSON.pretty_generate) that creates a more
+# readable output:
+#
+# puts JSON.pretty_generate([1, 2, {"a"=>3.141}, false, true, nil, 4..10])
+# [
+# 1,
+# 2,
+# {
+# "a": 3.141
+# },
+# false,
+# true,
+# null,
+# {
+# "json_class": "Range",
+# "data": [
+# 4,
+# 10,
+# false
+# ]
+# }
+# ]
+#
+# There are also the methods Kernel#j for unparse, and Kernel#jj for
+# pretty_unparse output to the console, that work analogous to Core Ruby's p
+# and the pp library's pp methods.
+#
+# The script tools/server.rb contains a small example if you want to test, how
+# receiving a JSON object from a webrick server in your browser with the
+# javasript prototype library (http://www.prototypejs.org) works.
+#
+module JSON
+ require 'json/version'
+
+ if VARIANT_BINARY
+ require 'json/ext'
+ else
+ begin
+ require 'json/ext'
+ rescue LoadError
+ require 'json/pure'
+ end
+ end
+
+ JSON_LOADED = true
+end
--- /dev/null
+# This file contains implementations of ruby core's custom objects for
+# serialisation/deserialisation.
+
+unless Object.const_defined?(:JSON) and ::JSON.const_defined?(:JSON_LOADED) and
+ ::JSON::JSON_LOADED
+ require 'json'
+end
+require 'date'
+
+class Time
+ def self.json_create(object)
+ if usec = object.delete('u') # used to be tv_usec -> tv_nsec
+ object['n'] = usec * 1000
+ end
+ if respond_to?(:tv_nsec)
+ at(*object.values_at('s', 'n'))
+ else
+ at(object['s'], object['n'] / 1000)
+ end
+ end
+
+ def to_json(*args)
+ {
+ 'json_class' => self.class.name,
+ 's' => tv_sec,
+ 'n' => respond_to?(:tv_nsec) ? tv_nsec : tv_usec * 1000
+ }.to_json(*args)
+ end
+end
+
+class Date
+ def self.json_create(object)
+ civil(*object.values_at('y', 'm', 'd', 'sg'))
+ end
+
+ alias start sg unless method_defined?(:start)
+
+ def to_json(*args)
+ {
+ 'json_class' => self.class.name,
+ 'y' => year,
+ 'm' => month,
+ 'd' => day,
+ 'sg' => start,
+ }.to_json(*args)
+ end
+end
+
+class DateTime
+ def self.json_create(object)
+ args = object.values_at('y', 'm', 'd', 'H', 'M', 'S')
+ of_a, of_b = object['of'].split('/')
+ if of_b and of_b != '0'
+ args << Rational(of_a.to_i, of_b.to_i)
+ else
+ args << of_a
+ end
+ args << object['sg']
+ civil(*args)
+ end
+
+ alias start sg unless method_defined?(:start)
+
+ def to_json(*args)
+ {
+ 'json_class' => self.class.name,
+ 'y' => year,
+ 'm' => month,
+ 'd' => day,
+ 'H' => hour,
+ 'M' => min,
+ 'S' => sec,
+ 'of' => offset.to_s,
+ 'sg' => start,
+ }.to_json(*args)
+ end
+end
+
+class Range
+ def self.json_create(object)
+ new(*object['a'])
+ end
+
+ def to_json(*args)
+ {
+ 'json_class' => self.class.name,
+ 'a' => [ first, last, exclude_end? ]
+ }.to_json(*args)
+ end
+end
+
+class Struct
+ def self.json_create(object)
+ new(*object['v'])
+ end
+
+ def to_json(*args)
+ klass = self.class.name
+ klass.nil? and raise JSON::JSONError, "Only named structs are supported!"
+ {
+ 'json_class' => klass,
+ 'v' => values,
+ }.to_json(*args)
+ end
+end
+
+class Exception
+ def self.json_create(object)
+ result = new(object['m'])
+ result.set_backtrace object['b']
+ result
+ end
+
+ def to_json(*args)
+ {
+ 'json_class' => self.class.name,
+ 'm' => message,
+ 'b' => backtrace,
+ }.to_json(*args)
+ end
+end
+
+class Regexp
+ def self.json_create(object)
+ new(object['s'], object['o'])
+ end
+
+ def to_json(*)
+ {
+ 'json_class' => self.class.name,
+ 'o' => options,
+ 's' => source,
+ }.to_json
+ end
+end
--- /dev/null
+# This file contains implementations of rails custom objects for
+# serialisation/deserialisation.
+
+unless Object.const_defined?(:JSON) and ::JSON.const_defined?(:JSON_LOADED) and
+ ::JSON::JSON_LOADED
+ require 'json'
+end
+
+class Object
+ def self.json_create(object)
+ obj = new
+ for key, value in object
+ next if key == 'json_class'
+ instance_variable_set "@#{key}", value
+ end
+ obj
+ end
+
+ def to_json(*a)
+ result = {
+ 'json_class' => self.class.name
+ }
+ instance_variables.inject(result) do |r, name|
+ r[name[1..-1]] = instance_variable_get name
+ r
+ end
+ result.to_json(*a)
+ end
+end
+
+class Symbol
+ def to_json(*a)
+ to_s.to_json(*a)
+ end
+end
+
+module Enumerable
+ def to_json(*a)
+ to_a.to_json(*a)
+ end
+end
+
+# class Regexp
+# def to_json(*)
+# inspect
+# end
+# end
+#
+# The above rails definition has some problems:
+#
+# 1. { 'foo' => /bar/ }.to_json # => "{foo: /bar/}"
+# This isn't valid JSON, because the regular expression syntax is not
+# defined in RFC 4627. (And unquoted strings are disallowed there, too.)
+# Though it is valid Javascript.
+#
+# 2. { 'foo' => /bar/mix }.to_json # => "{foo: /bar/mix}"
+# This isn't even valid Javascript.
+
--- /dev/null
+require 'json/version'
+
+module JSON
+ class << self
+ # If _object_ is string-like parse the string and return the parsed result
+ # as a Ruby data structure. Otherwise generate a JSON text from the Ruby
+ # data structure object and return it.
+ #
+ # The _opts_ argument is passed through to generate/parse respectively, see
+ # generate and parse for their documentation.
+ def [](object, opts = {})
+ if object.respond_to? :to_str
+ JSON.parse(object.to_str, opts => {})
+ else
+ JSON.generate(object, opts => {})
+ end
+ end
+
+ # Returns the JSON parser class, that is used by JSON. This might be either
+ # JSON::Ext::Parser or JSON::Pure::Parser.
+ attr_reader :parser
+
+ # Set the JSON parser class _parser_ to be used by JSON.
+ def parser=(parser) # :nodoc:
+ @parser = parser
+ remove_const :Parser if const_defined? :Parser
+ const_set :Parser, parser
+ end
+
+ # Return the constant located at _path_. The format of _path_ has to be
+ # either ::A::B::C or A::B::C. In any case A has to be located at the top
+ # level (absolute namespace path?). If there doesn't exist a constant at
+ # the given path, an ArgumentError is raised.
+ def deep_const_get(path) # :nodoc:
+ path = path.to_s
+ path.split(/::/).inject(Object) do |p, c|
+ case
+ when c.empty? then p
+ when p.const_defined?(c) then p.const_get(c)
+ else raise ArgumentError, "can't find const #{path}"
+ end
+ end
+ end
+
+ # Set the module _generator_ to be used by JSON.
+ def generator=(generator) # :nodoc:
+ @generator = generator
+ generator_methods = generator::GeneratorMethods
+ for const in generator_methods.constants
+ klass = deep_const_get(const)
+ modul = generator_methods.const_get(const)
+ klass.class_eval do
+ instance_methods(false).each do |m|
+ m.to_s == 'to_json' and remove_method m
+ end
+ include modul
+ end
+ end
+ self.state = generator::State
+ const_set :State, self.state
+ end
+
+ # Returns the JSON generator modul, that is used by JSON. This might be
+ # either JSON::Ext::Generator or JSON::Pure::Generator.
+ attr_reader :generator
+
+ # Returns the JSON generator state class, that is used by JSON. This might
+ # be either JSON::Ext::Generator::State or JSON::Pure::Generator::State.
+ attr_accessor :state
+
+ # This is create identifier, that is used to decide, if the _json_create_
+ # hook of a class should be called. It defaults to 'json_class'.
+ attr_accessor :create_id
+ end
+ self.create_id = 'json_class'
+
+ NaN = (-1.0) ** 0.5
+
+ Infinity = 1.0/0
+
+ MinusInfinity = -Infinity
+
+ # The base exception for JSON errors.
+ class JSONError < StandardError; end
+
+ # This exception is raised, if a parser error occurs.
+ class ParserError < JSONError; end
+
+ # This exception is raised, if the nesting of parsed datastructures is too
+ # deep.
+ class NestingError < ParserError; end
+
+ # This exception is raised, if a generator or unparser error occurs.
+ class GeneratorError < JSONError; end
+ # For backwards compatibility
+ UnparserError = GeneratorError
+
+ # If a circular data structure is encountered while unparsing
+ # this exception is raised.
+ class CircularDatastructure < GeneratorError; end
+
+ # This exception is raised, if the required unicode support is missing on the
+ # system. Usually this means, that the iconv library is not installed.
+ class MissingUnicodeSupport < JSONError; end
+
+ module_function
+
+ # Parse the JSON string _source_ into a Ruby data structure and return it.
+ #
+ # _opts_ can have the following
+ # keys:
+ # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+ # structures. Disable depth checking with :max_nesting => false, it defaults
+ # to 19.
+ # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+ # defiance of RFC 4627 to be parsed by the Parser. This option defaults
+ # to false.
+ # * *create_additions*: If set to false, the Parser doesn't create
+ # additions even if a matchin class and create_id was found. This option
+ # defaults to true.
+ def parse(source, opts = {})
+ JSON.parser.new(source, opts).parse
+ end
+
+ # Parse the JSON string _source_ into a Ruby data structure and return it.
+ # The bang version of the parse method, defaults to the more dangerous values
+ # for the _opts_ hash, so be sure only to parse trusted _source_ strings.
+ #
+ # _opts_ can have the following keys:
+ # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+ # structures. Enable depth checking with :max_nesting => anInteger. The parse!
+ # methods defaults to not doing max depth checking: This can be dangerous,
+ # if someone wants to fill up your stack.
+ # * *allow_nan*: If set to true, allow NaN, Infinity, and -Infinity in
+ # defiance of RFC 4627 to be parsed by the Parser. This option defaults
+ # to true.
+ # * *create_additions*: If set to false, the Parser doesn't create
+ # additions even if a matchin class and create_id was found. This option
+ # defaults to true.
+ def parse!(source, opts = {})
+ opts = {
+ :max_nesting => false,
+ :allow_nan => true
+ }.update(opts)
+ JSON.parser.new(source, opts).parse
+ end
+
+ # Unparse the Ruby data structure _obj_ into a single line JSON string and
+ # return it. _state_ is
+ # * a JSON::State object,
+ # * or a Hash like object (responding to to_hash),
+ # * an object convertible into a hash by a to_h method,
+ # that is used as or to configure a State object.
+ #
+ # It defaults to a state object, that creates the shortest possible JSON text
+ # in one line, checks for circular data structures and doesn't allow NaN,
+ # Infinity, and -Infinity.
+ #
+ # A _state_ hash can have the following keys:
+ # * *indent*: a string used to indent levels (default: ''),
+ # * *space*: a string that is put after, a : or , delimiter (default: ''),
+ # * *space_before*: a string that is put before a : pair delimiter (default: ''),
+ # * *object_nl*: a string that is put at the end of a JSON object (default: ''),
+ # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
+ # * *check_circular*: true if checking for circular data structures
+ # should be done (the default), false otherwise.
+ # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
+ # generated, otherwise an exception is thrown, if these values are
+ # encountered. This options defaults to false.
+ # * *max_nesting*: The maximum depth of nesting allowed in the data
+ # structures from which JSON is to be generated. Disable depth checking
+ # with :max_nesting => false, it defaults to 19.
+ #
+ # See also the fast_generate for the fastest creation method with the least
+ # amount of sanity checks, and the pretty_generate method for some
+ # defaults for a pretty output.
+ def generate(obj, state = nil)
+ if state
+ state = State.from_state(state)
+ else
+ state = State.new
+ end
+ obj.to_json(state)
+ end
+
+ # :stopdoc:
+ # I want to deprecate these later, so I'll first be silent about them, and
+ # later delete them.
+ alias unparse generate
+ module_function :unparse
+ # :startdoc:
+
+ # Unparse the Ruby data structure _obj_ into a single line JSON string and
+ # return it. This method disables the checks for circles in Ruby objects, and
+ # also generates NaN, Infinity, and, -Infinity float values.
+ #
+ # *WARNING*: Be careful not to pass any Ruby data structures with circles as
+ # _obj_ argument, because this will cause JSON to go into an infinite loop.
+ def fast_generate(obj)
+ obj.to_json(nil)
+ end
+
+ # :stopdoc:
+ # I want to deprecate these later, so I'll first be silent about them, and later delete them.
+ alias fast_unparse fast_generate
+ module_function :fast_unparse
+ # :startdoc:
+
+ # Unparse the Ruby data structure _obj_ into a JSON string and return it. The
+ # returned string is a prettier form of the string returned by #unparse.
+ #
+ # The _opts_ argument can be used to configure the generator, see the
+ # generate method for a more detailed explanation.
+ def pretty_generate(obj, opts = nil)
+ state = JSON.state.new(
+ :indent => ' ',
+ :space => ' ',
+ :object_nl => "\n",
+ :array_nl => "\n",
+ :check_circular => true
+ )
+ if opts
+ if opts.respond_to? :to_hash
+ opts = opts.to_hash
+ elsif opts.respond_to? :to_h
+ opts = opts.to_h
+ else
+ raise TypeError, "can't convert #{opts.class} into Hash"
+ end
+ state.configure(opts)
+ end
+ obj.to_json(state)
+ end
+
+ # :stopdoc:
+ # I want to deprecate these later, so I'll first be silent about them, and later delete them.
+ alias pretty_unparse pretty_generate
+ module_function :pretty_unparse
+ # :startdoc:
+
+ # Load a ruby data structure from a JSON _source_ and return it. A source can
+ # either be a string-like object, an IO like object, or an object responding
+ # to the read method. If _proc_ was given, it will be called with any nested
+ # Ruby object as an argument recursively in depth first order.
+ #
+ # This method is part of the implementation of the load/dump interface of
+ # Marshal and YAML.
+ def load(source, proc = nil)
+ if source.respond_to? :to_str
+ source = source.to_str
+ elsif source.respond_to? :to_io
+ source = source.to_io.read
+ else
+ source = source.read
+ end
+ result = parse(source, :max_nesting => false, :allow_nan => true)
+ recurse_proc(result, &proc) if proc
+ result
+ end
+
+ def recurse_proc(result, &proc)
+ case result
+ when Array
+ result.each { |x| recurse_proc x, &proc }
+ proc.call result
+ when Hash
+ result.each { |x, y| recurse_proc x, &proc; recurse_proc y, &proc }
+ proc.call result
+ else
+ proc.call result
+ end
+ end
+ private :recurse_proc
+ module_function :recurse_proc
+
+ alias restore load
+ module_function :restore
+
+ # Dumps _obj_ as a JSON string, i.e. calls generate on the object and returns
+ # the result.
+ #
+ # If anIO (an IO like object or an object that responds to the write method)
+ # was given, the resulting JSON is written to it.
+ #
+ # If the number of nested arrays or objects exceeds _limit_ an ArgumentError
+ # exception is raised. This argument is similar (but not exactly the
+ # same!) to the _limit_ argument in Marshal.dump.
+ #
+ # This method is part of the implementation of the load/dump interface of
+ # Marshal and YAML.
+ def dump(obj, anIO = nil, limit = nil)
+ if anIO and limit.nil?
+ anIO = anIO.to_io if anIO.respond_to?(:to_io)
+ unless anIO.respond_to?(:write)
+ limit = anIO
+ anIO = nil
+ end
+ end
+ limit ||= 0
+ result = generate(obj, :allow_nan => true, :max_nesting => limit)
+ if anIO
+ anIO.write result
+ anIO
+ else
+ result
+ end
+ rescue JSON::NestingError
+ raise ArgumentError, "exceed depth limit"
+ end
+end
+
+module ::Kernel
+ # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in
+ # one line.
+ def j(*objs)
+ objs.each do |obj|
+ puts JSON::generate(obj, :allow_nan => true, :max_nesting => false)
+ end
+ nil
+ end
+
+ # Ouputs _objs_ to STDOUT as JSON strings in a pretty format, with
+ # indentation and over many lines.
+ def jj(*objs)
+ objs.each do |obj|
+ puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)
+ end
+ nil
+ end
+
+ # If _object_ is string-like parse the string and return the parsed result as
+ # a Ruby data structure. Otherwise generate a JSON text from the Ruby data
+ # structure object and return it.
+ #
+ # The _opts_ argument is passed through to generate/parse respectively, see
+ # generate and parse for their documentation.
+ def JSON(object, opts = {})
+ if object.respond_to? :to_str
+ JSON.parse(object.to_str, opts)
+ else
+ JSON.generate(object, opts)
+ end
+ end
+end
+
+class ::Class
+ # Returns true, if this class can be used to create an instance
+ # from a serialised JSON string. The class has to implement a class
+ # method _json_create_ that expects a hash as first parameter, which includes
+ # the required data.
+ def json_creatable?
+ respond_to?(:json_create)
+ end
+end
--- /dev/null
+# To use the GUI JSON editor, start the edit_json.rb executable script. It
+# requires ruby-gtk to be installed.
+
+require 'gtk2'
+require 'iconv'
+require 'json'
+require 'rbconfig'
+require 'open-uri'
+
+module JSON
+ module Editor
+ include Gtk
+
+ # Beginning of the editor window title
+ TITLE = 'JSON Editor'.freeze
+
+ # Columns constants
+ ICON_COL, TYPE_COL, CONTENT_COL = 0, 1, 2
+
+ # JSON primitive types (Containers)
+ CONTAINER_TYPES = %w[Array Hash].sort
+ # All JSON primitive types
+ ALL_TYPES = (%w[TrueClass FalseClass Numeric String NilClass] +
+ CONTAINER_TYPES).sort
+
+ # The Nodes necessary for the tree representation of a JSON document
+ ALL_NODES = (ALL_TYPES + %w[Key]).sort
+
+ DEFAULT_DIALOG_KEY_PRESS_HANDLER = lambda do |dialog, event|
+ case event.keyval
+ when Gdk::Keyval::GDK_Return
+ dialog.response Dialog::RESPONSE_ACCEPT
+ when Gdk::Keyval::GDK_Escape
+ dialog.response Dialog::RESPONSE_REJECT
+ end
+ end
+
+ # Returns the Gdk::Pixbuf of the icon named _name_ from the icon cache.
+ def Editor.fetch_icon(name)
+ @icon_cache ||= {}
+ unless @icon_cache.key?(name)
+ path = File.dirname(__FILE__)
+ @icon_cache[name] = Gdk::Pixbuf.new(File.join(path, name + '.xpm'))
+ end
+ @icon_cache[name]
+ end
+
+ # Opens an error dialog on top of _window_ showing the error message
+ # _text_.
+ def Editor.error_dialog(window, text)
+ dialog = MessageDialog.new(window, Dialog::MODAL,
+ MessageDialog::ERROR,
+ MessageDialog::BUTTONS_CLOSE, text)
+ dialog.show_all
+ dialog.run
+ rescue TypeError
+ dialog = MessageDialog.new(Editor.window, Dialog::MODAL,
+ MessageDialog::ERROR,
+ MessageDialog::BUTTONS_CLOSE, text)
+ dialog.show_all
+ dialog.run
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Opens a yes/no question dialog on top of _window_ showing the error
+ # message _text_. If yes was answered _true_ is returned, otherwise
+ # _false_.
+ def Editor.question_dialog(window, text)
+ dialog = MessageDialog.new(window, Dialog::MODAL,
+ MessageDialog::QUESTION,
+ MessageDialog::BUTTONS_YES_NO, text)
+ dialog.show_all
+ dialog.run do |response|
+ return Gtk::Dialog::RESPONSE_YES === response
+ end
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Convert the tree model starting from Gtk::TreeIter _iter_ into a Ruby
+ # data structure and return it.
+ def Editor.model2data(iter)
+ return nil if iter.nil?
+ case iter.type
+ when 'Hash'
+ hash = {}
+ iter.each { |c| hash[c.content] = Editor.model2data(c.first_child) }
+ hash
+ when 'Array'
+ array = Array.new(iter.n_children)
+ iter.each_with_index { |c, i| array[i] = Editor.model2data(c) }
+ array
+ when 'Key'
+ iter.content
+ when 'String'
+ iter.content
+ when 'Numeric'
+ content = iter.content
+ if /\./.match(content)
+ content.to_f
+ else
+ content.to_i
+ end
+ when 'TrueClass'
+ true
+ when 'FalseClass'
+ false
+ when 'NilClass'
+ nil
+ else
+ fail "Unknown type found in model: #{iter.type}"
+ end
+ end
+
+ # Convert the Ruby data structure _data_ into tree model data for Gtk and
+ # returns the whole model. If the parameter _model_ wasn't given a new
+ # Gtk::TreeStore is created as the model. The _parent_ parameter specifies
+ # the parent node (iter, Gtk:TreeIter instance) to which the data is
+ # appended, alternativeley the result of the yielded block is used as iter.
+ def Editor.data2model(data, model = nil, parent = nil)
+ model ||= TreeStore.new(Gdk::Pixbuf, String, String)
+ iter = if block_given?
+ yield model
+ else
+ model.append(parent)
+ end
+ case data
+ when Hash
+ iter.type = 'Hash'
+ data.sort.each do |key, value|
+ pair_iter = model.append(iter)
+ pair_iter.type = 'Key'
+ pair_iter.content = key.to_s
+ Editor.data2model(value, model, pair_iter)
+ end
+ when Array
+ iter.type = 'Array'
+ data.each do |value|
+ Editor.data2model(value, model, iter)
+ end
+ when Numeric
+ iter.type = 'Numeric'
+ iter.content = data.to_s
+ when String, true, false, nil
+ iter.type = data.class.name
+ iter.content = data.nil? ? 'null' : data.to_s
+ else
+ iter.type = 'String'
+ iter.content = data.to_s
+ end
+ model
+ end
+
+ # The Gtk::TreeIter class is reopened and some auxiliary methods are added.
+ class Gtk::TreeIter
+ include Enumerable
+
+ # Traverse each of this Gtk::TreeIter instance's children
+ # and yield to them.
+ def each
+ n_children.times { |i| yield nth_child(i) }
+ end
+
+ # Recursively traverse all nodes of this Gtk::TreeIter's subtree
+ # (including self) and yield to them.
+ def recursive_each(&block)
+ yield self
+ each do |i|
+ i.recursive_each(&block)
+ end
+ end
+
+ # Remove the subtree of this Gtk::TreeIter instance from the
+ # model _model_.
+ def remove_subtree(model)
+ while current = first_child
+ model.remove(current)
+ end
+ end
+
+ # Returns the type of this node.
+ def type
+ self[TYPE_COL]
+ end
+
+ # Sets the type of this node to _value_. This implies setting
+ # the respective icon accordingly.
+ def type=(value)
+ self[TYPE_COL] = value
+ self[ICON_COL] = Editor.fetch_icon(value)
+ end
+
+ # Returns the content of this node.
+ def content
+ self[CONTENT_COL]
+ end
+
+ # Sets the content of this node to _value_.
+ def content=(value)
+ self[CONTENT_COL] = value
+ end
+ end
+
+ # This module bundles some method, that can be used to create a menu. It
+ # should be included into the class in question.
+ module MenuExtension
+ include Gtk
+
+ # Creates a Menu, that includes MenuExtension. _treeview_ is the
+ # Gtk::TreeView, on which it operates.
+ def initialize(treeview)
+ @treeview = treeview
+ @menu = Menu.new
+ end
+
+ # Returns the Gtk::TreeView of this menu.
+ attr_reader :treeview
+
+ # Returns the menu.
+ attr_reader :menu
+
+ # Adds a Gtk::SeparatorMenuItem to this instance's #menu.
+ def add_separator
+ menu.append SeparatorMenuItem.new
+ end
+
+ # Adds a Gtk::MenuItem to this instance's #menu. _label_ is the label
+ # string, _klass_ is the item type, and _callback_ is the procedure, that
+ # is called if the _item_ is activated.
+ def add_item(label, keyval = nil, klass = MenuItem, &callback)
+ label = "#{label} (C-#{keyval.chr})" if keyval
+ item = klass.new(label)
+ item.signal_connect(:activate, &callback)
+ if keyval
+ self.signal_connect(:'key-press-event') do |item, event|
+ if event.state & Gdk::Window::ModifierType::CONTROL_MASK != 0 and
+ event.keyval == keyval
+ callback.call item
+ end
+ end
+ end
+ menu.append item
+ item
+ end
+
+ # This method should be implemented in subclasses to create the #menu of
+ # this instance. It has to be called after an instance of this class is
+ # created, to build the menu.
+ def create
+ raise NotImplementedError
+ end
+
+ def method_missing(*a, &b)
+ treeview.__send__(*a, &b)
+ end
+ end
+
+ # This class creates the popup menu, that opens when clicking onto the
+ # treeview.
+ class PopUpMenu
+ include MenuExtension
+
+ # Change the type or content of the selected node.
+ def change_node(item)
+ if current = selection.selected
+ parent = current.parent
+ old_type, old_content = current.type, current.content
+ if ALL_TYPES.include?(old_type)
+ @clipboard_data = Editor.model2data(current)
+ type, content = ask_for_element(parent, current.type,
+ current.content)
+ if type
+ current.type, current.content = type, content
+ current.remove_subtree(model)
+ toplevel.display_status("Changed a node in tree.")
+ window.change
+ end
+ else
+ toplevel.display_status(
+ "Cannot change node of type #{old_type} in tree!")
+ end
+ end
+ end
+
+ # Cut the selected node and its subtree, and save it into the
+ # clipboard.
+ def cut_node(item)
+ if current = selection.selected
+ if current and current.type == 'Key'
+ @clipboard_data = {
+ current.content => Editor.model2data(current.first_child)
+ }
+ else
+ @clipboard_data = Editor.model2data(current)
+ end
+ model.remove(current)
+ window.change
+ toplevel.display_status("Cut a node from tree.")
+ end
+ end
+
+ # Copy the selected node and its subtree, and save it into the
+ # clipboard.
+ def copy_node(item)
+ if current = selection.selected
+ if current and current.type == 'Key'
+ @clipboard_data = {
+ current.content => Editor.model2data(current.first_child)
+ }
+ else
+ @clipboard_data = Editor.model2data(current)
+ end
+ window.change
+ toplevel.display_status("Copied a node from tree.")
+ end
+ end
+
+ # Paste the data in the clipboard into the selected Array or Hash by
+ # appending it.
+ def paste_node_appending(item)
+ if current = selection.selected
+ if @clipboard_data
+ case current.type
+ when 'Array'
+ Editor.data2model(@clipboard_data, model, current)
+ expand_collapse(current)
+ when 'Hash'
+ if @clipboard_data.is_a? Hash
+ parent = current.parent
+ hash = Editor.model2data(current)
+ model.remove(current)
+ hash.update(@clipboard_data)
+ Editor.data2model(hash, model, parent)
+ if parent
+ expand_collapse(parent)
+ elsif @expanded
+ expand_all
+ end
+ window.change
+ else
+ toplevel.display_status(
+ "Cannot paste non-#{current.type} data into '#{current.type}'!")
+ end
+ else
+ toplevel.display_status(
+ "Cannot paste node below '#{current.type}'!")
+ end
+ else
+ toplevel.display_status("Nothing to paste in clipboard!")
+ end
+ else
+ toplevel.display_status("Append a node into the root first!")
+ end
+ end
+
+ # Paste the data in the clipboard into the selected Array inserting it
+ # before the selected element.
+ def paste_node_inserting_before(item)
+ if current = selection.selected
+ if @clipboard_data
+ parent = current.parent or return
+ parent_type = parent.type
+ if parent_type == 'Array'
+ selected_index = parent.each_with_index do |c, i|
+ break i if c == current
+ end
+ Editor.data2model(@clipboard_data, model, parent) do |m|
+ m.insert_before(parent, current)
+ end
+ expand_collapse(current)
+ toplevel.display_status("Inserted an element to " +
+ "'#{parent_type}' before index #{selected_index}.")
+ window.change
+ else
+ toplevel.display_status(
+ "Cannot insert node below '#{parent_type}'!")
+ end
+ else
+ toplevel.display_status("Nothing to paste in clipboard!")
+ end
+ else
+ toplevel.display_status("Append a node into the root first!")
+ end
+ end
+
+ # Append a new node to the selected Hash or Array.
+ def append_new_node(item)
+ if parent = selection.selected
+ parent_type = parent.type
+ case parent_type
+ when 'Hash'
+ key, type, content = ask_for_hash_pair(parent)
+ key or return
+ iter = create_node(parent, 'Key', key)
+ iter = create_node(iter, type, content)
+ toplevel.display_status(
+ "Added a (key, value)-pair to '#{parent_type}'.")
+ window.change
+ when 'Array'
+ type, content = ask_for_element(parent)
+ type or return
+ iter = create_node(parent, type, content)
+ window.change
+ toplevel.display_status("Appendend an element to '#{parent_type}'.")
+ else
+ toplevel.display_status("Cannot append to '#{parent_type}'!")
+ end
+ else
+ type, content = ask_for_element
+ type or return
+ iter = create_node(nil, type, content)
+ window.change
+ end
+ end
+
+ # Insert a new node into an Array before the selected element.
+ def insert_new_node(item)
+ if current = selection.selected
+ parent = current.parent or return
+ parent_parent = parent.parent
+ parent_type = parent.type
+ if parent_type == 'Array'
+ selected_index = parent.each_with_index do |c, i|
+ break i if c == current
+ end
+ type, content = ask_for_element(parent)
+ type or return
+ iter = model.insert_before(parent, current)
+ iter.type, iter.content = type, content
+ toplevel.display_status("Inserted an element to " +
+ "'#{parent_type}' before index #{selected_index}.")
+ window.change
+ else
+ toplevel.display_status(
+ "Cannot insert node below '#{parent_type}'!")
+ end
+ else
+ toplevel.display_status("Append a node into the root first!")
+ end
+ end
+
+ # Recursively collapse/expand a subtree starting from the selected node.
+ def collapse_expand(item)
+ if current = selection.selected
+ if row_expanded?(current.path)
+ collapse_row(current.path)
+ else
+ expand_row(current.path, true)
+ end
+ else
+ toplevel.display_status("Append a node into the root first!")
+ end
+ end
+
+ # Create the menu.
+ def create
+ add_item("Change node", ?n, &method(:change_node))
+ add_separator
+ add_item("Cut node", ?X, &method(:cut_node))
+ add_item("Copy node", ?C, &method(:copy_node))
+ add_item("Paste node (appending)", ?A, &method(:paste_node_appending))
+ add_item("Paste node (inserting before)", ?I,
+ &method(:paste_node_inserting_before))
+ add_separator
+ add_item("Append new node", ?a, &method(:append_new_node))
+ add_item("Insert new node before", ?i, &method(:insert_new_node))
+ add_separator
+ add_item("Collapse/Expand node (recursively)", ?e,
+ &method(:collapse_expand))
+
+ menu.show_all
+ signal_connect(:button_press_event) do |widget, event|
+ if event.kind_of? Gdk::EventButton and event.button == 3
+ menu.popup(nil, nil, event.button, event.time)
+ end
+ end
+ signal_connect(:popup_menu) do
+ menu.popup(nil, nil, 0, Gdk::Event::CURRENT_TIME)
+ end
+ end
+ end
+
+ # This class creates the File pulldown menu.
+ class FileMenu
+ include MenuExtension
+
+ # Clear the model and filename, but ask to save the JSON document, if
+ # unsaved changes have occured.
+ def new(item)
+ window.clear
+ end
+
+ # Open a file and load it into the editor. Ask to save the JSON document
+ # first, if unsaved changes have occured.
+ def open(item)
+ window.file_open
+ end
+
+ def open_location(item)
+ window.location_open
+ end
+
+ # Revert the current JSON document in the editor to the saved version.
+ def revert(item)
+ window.instance_eval do
+ @filename and file_open(@filename)
+ end
+ end
+
+ # Save the current JSON document.
+ def save(item)
+ window.file_save
+ end
+
+ # Save the current JSON document under the given filename.
+ def save_as(item)
+ window.file_save_as
+ end
+
+ # Quit the editor, after asking to save any unsaved changes first.
+ def quit(item)
+ window.quit
+ end
+
+ # Create the menu.
+ def create
+ title = MenuItem.new('File')
+ title.submenu = menu
+ add_item('New', &method(:new))
+ add_item('Open', ?o, &method(:open))
+ add_item('Open location', ?l, &method(:open_location))
+ add_item('Revert', &method(:revert))
+ add_separator
+ add_item('Save', ?s, &method(:save))
+ add_item('Save As', ?S, &method(:save_as))
+ add_separator
+ add_item('Quit', ?q, &method(:quit))
+ title
+ end
+ end
+
+ # This class creates the Edit pulldown menu.
+ class EditMenu
+ include MenuExtension
+
+ # Copy data from model into primary clipboard.
+ def copy(item)
+ data = Editor.model2data(model.iter_first)
+ json = JSON.pretty_generate(data, :max_nesting => false)
+ c = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+ c.text = json
+ end
+
+ # Copy json text from primary clipboard into model.
+ def paste(item)
+ c = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+ if json = c.wait_for_text
+ window.ask_save if @changed
+ begin
+ window.edit json
+ rescue JSON::ParserError
+ window.clear
+ end
+ end
+ end
+
+ # Find a string in all nodes' contents and select the found node in the
+ # treeview.
+ def find(item)
+ @search = ask_for_find_term(@search) or return
+ iter = model.get_iter('0') or return
+ iter.recursive_each do |i|
+ if @iter
+ if @iter != i
+ next
+ else
+ @iter = nil
+ next
+ end
+ elsif @search.match(i[CONTENT_COL])
+ set_cursor(i.path, nil, false)
+ @iter = i
+ break
+ end
+ end
+ end
+
+ # Repeat the last search given by #find.
+ def find_again(item)
+ @search or return
+ iter = model.get_iter('0')
+ iter.recursive_each do |i|
+ if @iter
+ if @iter != i
+ next
+ else
+ @iter = nil
+ next
+ end
+ elsif @search.match(i[CONTENT_COL])
+ set_cursor(i.path, nil, false)
+ @iter = i
+ break
+ end
+ end
+ end
+
+ # Sort (Reverse sort) all elements of the selected array by the given
+ # expression. _x_ is the element in question.
+ def sort(item)
+ if current = selection.selected
+ if current.type == 'Array'
+ parent = current.parent
+ ary = Editor.model2data(current)
+ order, reverse = ask_for_order
+ order or return
+ begin
+ block = eval "lambda { |x| #{order} }"
+ if reverse
+ ary.sort! { |a,b| block[b] <=> block[a] }
+ else
+ ary.sort! { |a,b| block[a] <=> block[b] }
+ end
+ rescue => e
+ Editor.error_dialog(self, "Failed to sort Array with #{order}: #{e}!")
+ else
+ Editor.data2model(ary, model, parent) do |m|
+ m.insert_before(parent, current)
+ end
+ model.remove(current)
+ expand_collapse(parent)
+ window.change
+ toplevel.display_status("Array has been sorted.")
+ end
+ else
+ toplevel.display_status("Only Array nodes can be sorted!")
+ end
+ else
+ toplevel.display_status("Select an Array to sort first!")
+ end
+ end
+
+ # Create the menu.
+ def create
+ title = MenuItem.new('Edit')
+ title.submenu = menu
+ add_item('Copy', ?c, &method(:copy))
+ add_item('Paste', ?v, &method(:paste))
+ add_separator
+ add_item('Find', ?f, &method(:find))
+ add_item('Find Again', ?g, &method(:find_again))
+ add_separator
+ add_item('Sort', ?S, &method(:sort))
+ title
+ end
+ end
+
+ class OptionsMenu
+ include MenuExtension
+
+ # Collapse/Expand all nodes by default.
+ def collapsed_nodes(item)
+ if expanded
+ self.expanded = false
+ collapse_all
+ else
+ self.expanded = true
+ expand_all
+ end
+ end
+
+ # Toggle pretty saving mode on/off.
+ def pretty_saving(item)
+ @pretty_item.toggled
+ window.change
+ end
+
+ attr_reader :pretty_item
+
+ # Create the menu.
+ def create
+ title = MenuItem.new('Options')
+ title.submenu = menu
+ add_item('Collapsed nodes', nil, CheckMenuItem, &method(:collapsed_nodes))
+ @pretty_item = add_item('Pretty saving', nil, CheckMenuItem,
+ &method(:pretty_saving))
+ @pretty_item.active = true
+ window.unchange
+ title
+ end
+ end
+
+ # This class inherits from Gtk::TreeView, to configure it and to add a lot
+ # of behaviour to it.
+ class JSONTreeView < Gtk::TreeView
+ include Gtk
+
+ # Creates a JSONTreeView instance, the parameter _window_ is
+ # a MainWindow instance and used for self delegation.
+ def initialize(window)
+ @window = window
+ super(TreeStore.new(Gdk::Pixbuf, String, String))
+ self.selection.mode = SELECTION_BROWSE
+
+ @expanded = false
+ self.headers_visible = false
+ add_columns
+ add_popup_menu
+ end
+
+ # Returns the MainWindow instance of this JSONTreeView.
+ attr_reader :window
+
+ # Returns true, if nodes are autoexpanding, false otherwise.
+ attr_accessor :expanded
+
+ private
+
+ def add_columns
+ cell = CellRendererPixbuf.new
+ column = TreeViewColumn.new('Icon', cell,
+ 'pixbuf' => ICON_COL
+ )
+ append_column(column)
+
+ cell = CellRendererText.new
+ column = TreeViewColumn.new('Type', cell,
+ 'text' => TYPE_COL
+ )
+ append_column(column)
+
+ cell = CellRendererText.new
+ cell.editable = true
+ column = TreeViewColumn.new('Content', cell,
+ 'text' => CONTENT_COL
+ )
+ cell.signal_connect(:edited, &method(:cell_edited))
+ append_column(column)
+ end
+
+ def unify_key(iter, key)
+ return unless iter.type == 'Key'
+ parent = iter.parent
+ if parent.any? { |c| c != iter and c.content == key }
+ old_key = key
+ i = 0
+ begin
+ key = sprintf("%s.%d", old_key, i += 1)
+ end while parent.any? { |c| c != iter and c.content == key }
+ end
+ iter.content = key
+ end
+
+ def cell_edited(cell, path, value)
+ iter = model.get_iter(path)
+ case iter.type
+ when 'Key'
+ unify_key(iter, value)
+ toplevel.display_status('Key has been changed.')
+ when 'FalseClass'
+ value.downcase!
+ if value == 'true'
+ iter.type, iter.content = 'TrueClass', 'true'
+ end
+ when 'TrueClass'
+ value.downcase!
+ if value == 'false'
+ iter.type, iter.content = 'FalseClass', 'false'
+ end
+ when 'Numeric'
+ iter.content = (Integer(value) rescue Float(value) rescue 0).to_s
+ when 'String'
+ iter.content = value
+ when 'Hash', 'Array'
+ return
+ else
+ fail "Unknown type found in model: #{iter.type}"
+ end
+ window.change
+ end
+
+ def configure_value(value, type)
+ value.editable = false
+ case type
+ when 'Array', 'Hash'
+ value.text = ''
+ when 'TrueClass'
+ value.text = 'true'
+ when 'FalseClass'
+ value.text = 'false'
+ when 'NilClass'
+ value.text = 'null'
+ when 'Numeric', 'String'
+ value.text ||= ''
+ value.editable = true
+ else
+ raise ArgumentError, "unknown type '#{type}' encountered"
+ end
+ end
+
+ def add_popup_menu
+ menu = PopUpMenu.new(self)
+ menu.create
+ end
+
+ public
+
+ # Create a _type_ node with content _content_, and add it to _parent_
+ # in the model. If _parent_ is nil, create a new model and put it into
+ # the editor treeview.
+ def create_node(parent, type, content)
+ iter = if parent
+ model.append(parent)
+ else
+ new_model = Editor.data2model(nil)
+ toplevel.view_new_model(new_model)
+ new_model.iter_first
+ end
+ iter.type, iter.content = type, content
+ expand_collapse(parent) if parent
+ iter
+ end
+
+ # Ask for a hash key, value pair to be added to the Hash node _parent_.
+ def ask_for_hash_pair(parent)
+ key_input = type_input = value_input = nil
+
+ dialog = Dialog.new("New (key, value) pair for Hash", nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ dialog.width_request = 640
+
+ hbox = HBox.new(false, 5)
+ hbox.pack_start(Label.new("Key:"), false)
+ hbox.pack_start(key_input = Entry.new)
+ key_input.text = @key || ''
+ dialog.vbox.pack_start(hbox, false)
+ key_input.signal_connect(:activate) do
+ if parent.any? { |c| c.content == key_input.text }
+ toplevel.display_status('Key already exists in Hash!')
+ key_input.text = ''
+ else
+ toplevel.display_status('Key has been changed.')
+ end
+ end
+
+ hbox = HBox.new(false, 5)
+ hbox.pack_start(Label.new("Type:"), false)
+ hbox.pack_start(type_input = ComboBox.new(true))
+ ALL_TYPES.each { |t| type_input.append_text(t) }
+ type_input.active = @type || 0
+ dialog.vbox.pack_start(hbox, false)
+
+ type_input.signal_connect(:changed) do
+ value_input.editable = false
+ case ALL_TYPES[type_input.active]
+ when 'Array', 'Hash'
+ value_input.text = ''
+ when 'TrueClass'
+ value_input.text = 'true'
+ when 'FalseClass'
+ value_input.text = 'false'
+ when 'NilClass'
+ value_input.text = 'null'
+ else
+ value_input.text = ''
+ value_input.editable = true
+ end
+ end
+
+ hbox = HBox.new(false, 5)
+ hbox.pack_start(Label.new("Value:"), false)
+ hbox.pack_start(value_input = Entry.new)
+ value_input.width_chars = 60
+ value_input.text = @value || ''
+ dialog.vbox.pack_start(hbox, false)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ self.focus = dialog
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ @key = key_input.text
+ type = ALL_TYPES[@type = type_input.active]
+ content = value_input.text
+ return @key, type, content
+ end
+ end
+ return
+ ensure
+ dialog.destroy
+ end
+
+ # Ask for an element to be appended _parent_.
+ def ask_for_element(parent = nil, default_type = nil, value_text = @content)
+ type_input = value_input = nil
+
+ dialog = Dialog.new(
+ "New element into #{parent ? parent.type : 'root'}",
+ nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ hbox = HBox.new(false, 5)
+ hbox.pack_start(Label.new("Type:"), false)
+ hbox.pack_start(type_input = ComboBox.new(true))
+ default_active = 0
+ types = parent ? ALL_TYPES : CONTAINER_TYPES
+ types.each_with_index do |t, i|
+ type_input.append_text(t)
+ if t == default_type
+ default_active = i
+ end
+ end
+ type_input.active = default_active
+ dialog.vbox.pack_start(hbox, false)
+ type_input.signal_connect(:changed) do
+ configure_value(value_input, types[type_input.active])
+ end
+
+ hbox = HBox.new(false, 5)
+ hbox.pack_start(Label.new("Value:"), false)
+ hbox.pack_start(value_input = Entry.new)
+ value_input.width_chars = 60
+ value_input.text = value_text if value_text
+ configure_value(value_input, types[type_input.active])
+
+ dialog.vbox.pack_start(hbox, false)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ self.focus = dialog
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ type = types[type_input.active]
+ @content = case type
+ when 'Numeric'
+ Integer(value_input.text) rescue Float(value_input.text) rescue 0
+ else
+ value_input.text
+ end.to_s
+ return type, @content
+ end
+ end
+ return
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Ask for an order criteria for sorting, using _x_ for the element in
+ # question. Returns the order criterium, and true/false for reverse
+ # sorting.
+ def ask_for_order
+ dialog = Dialog.new(
+ "Give an order criterium for 'x'.",
+ nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ hbox = HBox.new(false, 5)
+
+ hbox.pack_start(Label.new("Order:"), false)
+ hbox.pack_start(order_input = Entry.new)
+ order_input.text = @order || 'x'
+ order_input.width_chars = 60
+
+ hbox.pack_start(reverse_checkbox = CheckButton.new('Reverse'), false)
+
+ dialog.vbox.pack_start(hbox, false)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ self.focus = dialog
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ return @order = order_input.text, reverse_checkbox.active?
+ end
+ end
+ return
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Ask for a find term to search for in the tree. Returns the term as a
+ # string.
+ def ask_for_find_term(search = nil)
+ dialog = Dialog.new(
+ "Find a node matching regex in tree.",
+ nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ hbox = HBox.new(false, 5)
+
+ hbox.pack_start(Label.new("Regex:"), false)
+ hbox.pack_start(regex_input = Entry.new)
+ hbox.pack_start(icase_checkbox = CheckButton.new('Icase'), false)
+ regex_input.width_chars = 60
+ if search
+ regex_input.text = search.source
+ icase_checkbox.active = search.casefold?
+ end
+
+ dialog.vbox.pack_start(hbox, false)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ self.focus = dialog
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ begin
+ return Regexp.new(regex_input.text, icase_checkbox.active? ? Regexp::IGNORECASE : 0)
+ rescue => e
+ Editor.error_dialog(self, "Evaluation of regex /#{regex_input.text}/ failed: #{e}!")
+ return
+ end
+ end
+ end
+ return
+ ensure
+ dialog.destroy if dialog
+ end
+
+ # Expand or collapse row pointed to by _iter_ according
+ # to the #expanded attribute.
+ def expand_collapse(iter)
+ if expanded
+ expand_row(iter.path, true)
+ else
+ collapse_row(iter.path)
+ end
+ end
+ end
+
+ # The editor main window
+ class MainWindow < Gtk::Window
+ include Gtk
+
+ def initialize(encoding)
+ @changed = false
+ @encoding = encoding
+ super(TOPLEVEL)
+ display_title
+ set_default_size(800, 600)
+ signal_connect(:delete_event) { quit }
+
+ vbox = VBox.new(false, 0)
+ add(vbox)
+ #vbox.border_width = 0
+
+ @treeview = JSONTreeView.new(self)
+ @treeview.signal_connect(:'cursor-changed') do
+ display_status('')
+ end
+
+ menu_bar = create_menu_bar
+ vbox.pack_start(menu_bar, false, false, 0)
+
+ sw = ScrolledWindow.new(nil, nil)
+ sw.shadow_type = SHADOW_ETCHED_IN
+ sw.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC)
+ vbox.pack_start(sw, true, true, 0)
+ sw.add(@treeview)
+
+ @status_bar = Statusbar.new
+ vbox.pack_start(@status_bar, false, false, 0)
+
+ @filename ||= nil
+ if @filename
+ data = read_data(@filename)
+ view_new_model Editor.data2model(data)
+ end
+
+ signal_connect(:button_release_event) do |_,event|
+ if event.button == 2
+ c = Gtk::Clipboard.get(Gdk::Selection::PRIMARY)
+ if url = c.wait_for_text
+ location_open url
+ end
+ false
+ else
+ true
+ end
+ end
+ end
+
+ # Creates the menu bar with the pulldown menus and returns it.
+ def create_menu_bar
+ menu_bar = MenuBar.new
+ @file_menu = FileMenu.new(@treeview)
+ menu_bar.append @file_menu.create
+ @edit_menu = EditMenu.new(@treeview)
+ menu_bar.append @edit_menu.create
+ @options_menu = OptionsMenu.new(@treeview)
+ menu_bar.append @options_menu.create
+ menu_bar
+ end
+
+ # Sets editor status to changed, to indicate that the edited data
+ # containts unsaved changes.
+ def change
+ @changed = true
+ display_title
+ end
+
+ # Sets editor status to unchanged, to indicate that the edited data
+ # doesn't containt unsaved changes.
+ def unchange
+ @changed = false
+ display_title
+ end
+
+ # Puts a new model _model_ into the Gtk::TreeView to be edited.
+ def view_new_model(model)
+ @treeview.model = model
+ @treeview.expanded = true
+ @treeview.expand_all
+ unchange
+ end
+
+ # Displays _text_ in the status bar.
+ def display_status(text)
+ @cid ||= nil
+ @status_bar.pop(@cid) if @cid
+ @cid = @status_bar.get_context_id('dummy')
+ @status_bar.push(@cid, text)
+ end
+
+ # Opens a dialog, asking, if changes should be saved to a file.
+ def ask_save
+ if Editor.question_dialog(self,
+ "Unsaved changes to JSON model. Save?")
+ if @filename
+ file_save
+ else
+ file_save_as
+ end
+ end
+ end
+
+ # Quit this editor, that is, leave this editor's main loop.
+ def quit
+ ask_save if @changed
+ if Gtk.main_level > 0
+ destroy
+ Gtk.main_quit
+ end
+ nil
+ end
+
+ # Display the new title according to the editor's current state.
+ def display_title
+ title = TITLE.dup
+ title << ": #@filename" if @filename
+ title << " *" if @changed
+ self.title = title
+ end
+
+ # Clear the current model, after asking to save all unsaved changes.
+ def clear
+ ask_save if @changed
+ @filename = nil
+ self.view_new_model nil
+ end
+
+ def check_pretty_printed(json)
+ pretty = !!((nl_index = json.index("\n")) && nl_index != json.size - 1)
+ @options_menu.pretty_item.active = pretty
+ end
+ private :check_pretty_printed
+
+ # Open the data at the location _uri_, if given. Otherwise open a dialog
+ # to ask for the _uri_.
+ def location_open(uri = nil)
+ uri = ask_for_location unless uri
+ uri or return
+ ask_save if @changed
+ data = load_location(uri) or return
+ view_new_model Editor.data2model(data)
+ end
+
+ # Open the file _filename_ or call the #select_file method to ask for a
+ # filename.
+ def file_open(filename = nil)
+ filename = select_file('Open as a JSON file') unless filename
+ data = load_file(filename) or return
+ view_new_model Editor.data2model(data)
+ end
+
+ # Edit the string _json_ in the editor.
+ def edit(json)
+ if json.respond_to? :read
+ json = json.read
+ end
+ data = parse_json json
+ view_new_model Editor.data2model(data)
+ end
+
+ # Save the current file.
+ def file_save
+ if @filename
+ store_file(@filename)
+ else
+ file_save_as
+ end
+ end
+
+ # Save the current file as the filename
+ def file_save_as
+ filename = select_file('Save as a JSON file')
+ store_file(filename)
+ end
+
+ # Store the current JSON document to _path_.
+ def store_file(path)
+ if path
+ data = Editor.model2data(@treeview.model.iter_first)
+ File.open(path + '.tmp', 'wb') do |output|
+ data or break
+ if @options_menu.pretty_item.active?
+ output.puts JSON.pretty_generate(data, :max_nesting => false)
+ else
+ output.write JSON.generate(data, :max_nesting => false)
+ end
+ end
+ File.rename path + '.tmp', path
+ @filename = path
+ toplevel.display_status("Saved data to '#@filename'.")
+ unchange
+ end
+ rescue SystemCallError => e
+ Editor.error_dialog(self, "Failed to store JSON file: #{e}!")
+ end
+
+ # Load the file named _filename_ into the editor as a JSON document.
+ def load_file(filename)
+ if filename
+ if File.directory?(filename)
+ Editor.error_dialog(self, "Try to select a JSON file!")
+ nil
+ else
+ @filename = filename
+ if data = read_data(filename)
+ toplevel.display_status("Loaded data from '#@filename'.")
+ end
+ display_title
+ data
+ end
+ end
+ end
+
+ # Load the data at location _uri_ into the editor as a JSON document.
+ def load_location(uri)
+ data = read_data(uri) or return
+ @filename = nil
+ toplevel.display_status("Loaded data from '#{uri}'.")
+ display_title
+ data
+ end
+
+ def parse_json(json)
+ check_pretty_printed(json)
+ if @encoding && !/^utf8$/i.match(@encoding)
+ iconverter = Iconv.new('utf8', @encoding)
+ json = iconverter.iconv(json)
+ end
+ JSON::parse(json, :max_nesting => false, :create_additions => false)
+ end
+ private :parse_json
+
+ # Read a JSON document from the file named _filename_, parse it into a
+ # ruby data structure, and return the data.
+ def read_data(filename)
+ open(filename) do |f|
+ json = f.read
+ return parse_json(json)
+ end
+ rescue => e
+ Editor.error_dialog(self, "Failed to parse JSON file: #{e}!")
+ return
+ end
+
+ # Open a file selecton dialog, displaying _message_, and return the
+ # selected filename or nil, if no file was selected.
+ def select_file(message)
+ filename = nil
+ fs = FileSelection.new(message)
+ fs.set_modal(true)
+ @default_dir = File.join(Dir.pwd, '') unless @default_dir
+ fs.set_filename(@default_dir)
+ fs.set_transient_for(self)
+ fs.signal_connect(:destroy) { Gtk.main_quit }
+ fs.ok_button.signal_connect(:clicked) do
+ filename = fs.filename
+ @default_dir = File.join(File.dirname(filename), '')
+ fs.destroy
+ Gtk.main_quit
+ end
+ fs.cancel_button.signal_connect(:clicked) do
+ fs.destroy
+ Gtk.main_quit
+ end
+ fs.show_all
+ Gtk.main
+ filename
+ end
+
+ # Ask for location URI a to load data from. Returns the URI as a string.
+ def ask_for_location
+ dialog = Dialog.new(
+ "Load data from location...",
+ nil, nil,
+ [ Stock::OK, Dialog::RESPONSE_ACCEPT ],
+ [ Stock::CANCEL, Dialog::RESPONSE_REJECT ]
+ )
+ hbox = HBox.new(false, 5)
+
+ hbox.pack_start(Label.new("Location:"), false)
+ hbox.pack_start(location_input = Entry.new)
+ location_input.width_chars = 60
+ location_input.text = @location || ''
+
+ dialog.vbox.pack_start(hbox, false)
+
+ dialog.signal_connect(:'key-press-event', &DEFAULT_DIALOG_KEY_PRESS_HANDLER)
+ dialog.show_all
+ dialog.run do |response|
+ if response == Dialog::RESPONSE_ACCEPT
+ return @location = location_input.text
+ end
+ end
+ return
+ ensure
+ dialog.destroy if dialog
+ end
+ end
+
+ class << self
+ # Starts a JSON Editor. If a block was given, it yields
+ # to the JSON::Editor::MainWindow instance.
+ def start(encoding = 'utf8') # :yield: window
+ Gtk.init
+ @window = Editor::MainWindow.new(encoding)
+ @window.icon_list = [ Editor.fetch_icon('json') ]
+ yield @window if block_given?
+ @window.show_all
+ Gtk.main
+ end
+
+ # Edit the string _json_ with encoding _encoding_ in the editor.
+ def edit(json, encoding = 'utf8')
+ start(encoding) do |window|
+ window.edit json
+ end
+ end
+
+ attr_reader :window
+ end
+ end
+end
--- /dev/null
+require 'json/common'
+
+module JSON
+ # This module holds all the modules/classes that implement JSON's
+ # functionality as C extensions.
+ module Ext
+ require 'json/ext/parser'
+ require 'json/ext/generator'
+ $DEBUG and warn "Using c extension for JSON."
+ JSON.parser = Parser
+ JSON.generator = Generator
+ end
+end
--- /dev/null
+require 'json/common'
+require 'json/pure/parser'
+require 'json/pure/generator'
+
+module JSON
+ # Swap consecutive bytes of _string_ in place.
+ def self.swap!(string) # :nodoc:
+ 0.upto(string.size / 2) do |i|
+ break unless string[2 * i + 1]
+ string[2 * i], string[2 * i + 1] = string[2 * i + 1], string[2 * i]
+ end
+ string
+ end
+
+ # This module holds all the modules/classes that implement JSON's
+ # functionality in pure ruby.
+ module Pure
+ $DEBUG and warn "Using pure library for JSON."
+ JSON.parser = Parser
+ JSON.generator = Generator
+ end
+end
--- /dev/null
+module JSON
+ MAP = {
+ "\x0" => '\u0000',
+ "\x1" => '\u0001',
+ "\x2" => '\u0002',
+ "\x3" => '\u0003',
+ "\x4" => '\u0004',
+ "\x5" => '\u0005',
+ "\x6" => '\u0006',
+ "\x7" => '\u0007',
+ "\b" => '\b',
+ "\t" => '\t',
+ "\n" => '\n',
+ "\xb" => '\u000b',
+ "\f" => '\f',
+ "\r" => '\r',
+ "\xe" => '\u000e',
+ "\xf" => '\u000f',
+ "\x10" => '\u0010',
+ "\x11" => '\u0011',
+ "\x12" => '\u0012',
+ "\x13" => '\u0013',
+ "\x14" => '\u0014',
+ "\x15" => '\u0015',
+ "\x16" => '\u0016',
+ "\x17" => '\u0017',
+ "\x18" => '\u0018',
+ "\x19" => '\u0019',
+ "\x1a" => '\u001a',
+ "\x1b" => '\u001b',
+ "\x1c" => '\u001c',
+ "\x1d" => '\u001d',
+ "\x1e" => '\u001e',
+ "\x1f" => '\u001f',
+ '"' => '\"',
+ '\\' => '\\\\',
+ '/' => '\/',
+ } # :nodoc:
+
+ # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
+ # UTF16 big endian characters as \u????, and return it.
+ def utf8_to_json(string) # :nodoc:
+ string = string.dup.force_encoding(Encoding::ASCII_8BIT)
+ string.gsub!(/["\\\/\x0-\x1f]/) { MAP[$&] }
+ string.gsub!(/(
+ (?:
+ [\xc2-\xdf][\x80-\xbf] |
+ [\xe0-\xef][\x80-\xbf]{2} |
+ [\xf0-\xf4][\x80-\xbf]{3}
+ )+ |
+ [\x80-\xc1\xf5-\xff] # invalid
+ )/nx) { |c|
+ c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
+ c.unpack("U*").map{|c|
+ c>0xFFFF ? ('\ud%03x\ud%03x'%[0x7C0+c/1024,0xC00+c%1024]) : ('\u%04x'%c)
+ }.join("")
+ }
+ string
+ end
+ module_function :utf8_to_json
+
+ module Pure
+ module Generator
+ # This class is used to create State instances, that are use to hold data
+ # while generating a JSON text from a a Ruby data structure.
+ class State
+ # Creates a State object from _opts_, which ought to be Hash to create
+ # a new State instance configured by _opts_, something else to create
+ # an unconfigured instance. If _opts_ is a State object, it is just
+ # returned.
+ def self.from_state(opts)
+ case opts
+ when self
+ opts
+ when Hash
+ new(opts)
+ else
+ new
+ end
+ end
+
+ # Instantiates a new State object, configured by _opts_.
+ #
+ # _opts_ can have the following keys:
+ #
+ # * *indent*: a string used to indent levels (default: ''),
+ # * *space*: a string that is put after, a : or , delimiter (default: ''),
+ # * *space_before*: a string that is put before a : pair delimiter (default: ''),
+ # * *object_nl*: a string that is put at the end of a JSON object (default: ''),
+ # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
+ # * *check_circular*: true if checking for circular data structures
+ # should be done (the default), false otherwise.
+ # * *check_circular*: true if checking for circular data structures
+ # should be done, false (the default) otherwise.
+ # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
+ # generated, otherwise an exception is thrown, if these values are
+ # encountered. This options defaults to false.
+ def initialize(opts = {})
+ @seen = {}
+ @indent = ''
+ @space = ''
+ @space_before = ''
+ @object_nl = ''
+ @array_nl = ''
+ @check_circular = true
+ @allow_nan = false
+ configure opts
+ end
+
+ # This string is used to indent levels in the JSON text.
+ attr_accessor :indent
+
+ # This string is used to insert a space between the tokens in a JSON
+ # string.
+ attr_accessor :space
+
+ # This string is used to insert a space before the ':' in JSON objects.
+ attr_accessor :space_before
+
+ # This string is put at the end of a line that holds a JSON object (or
+ # Hash).
+ attr_accessor :object_nl
+
+ # This string is put at the end of a line that holds a JSON array.
+ attr_accessor :array_nl
+
+ # This integer returns the maximum level of data structure nesting in
+ # the generated JSON, max_nesting = 0 if no maximum is checked.
+ attr_accessor :max_nesting
+
+ def check_max_nesting(depth) # :nodoc:
+ return if @max_nesting.zero?
+ current_nesting = depth + 1
+ current_nesting > @max_nesting and
+ raise NestingError, "nesting of #{current_nesting} is too deep"
+ end
+
+ # Returns true, if circular data structures should be checked,
+ # otherwise returns false.
+ def check_circular?
+ @check_circular
+ end
+
+ # Returns true if NaN, Infinity, and -Infinity should be considered as
+ # valid JSON and output.
+ def allow_nan?
+ @allow_nan
+ end
+
+ # Returns _true_, if _object_ was already seen during this generating
+ # run.
+ def seen?(object)
+ @seen.key?(object.__id__)
+ end
+
+ # Remember _object_, to find out if it was already encountered (if a
+ # cyclic data structure is if a cyclic data structure is rendered).
+ def remember(object)
+ @seen[object.__id__] = true
+ end
+
+ # Forget _object_ for this generating run.
+ def forget(object)
+ @seen.delete object.__id__
+ end
+
+ # Configure this State instance with the Hash _opts_, and return
+ # itself.
+ def configure(opts)
+ @indent = opts[:indent] if opts.key?(:indent)
+ @space = opts[:space] if opts.key?(:space)
+ @space_before = opts[:space_before] if opts.key?(:space_before)
+ @object_nl = opts[:object_nl] if opts.key?(:object_nl)
+ @array_nl = opts[:array_nl] if opts.key?(:array_nl)
+ @check_circular = !!opts[:check_circular] if opts.key?(:check_circular)
+ @allow_nan = !!opts[:allow_nan] if opts.key?(:allow_nan)
+ if !opts.key?(:max_nesting) # defaults to 19
+ @max_nesting = 19
+ elsif opts[:max_nesting]
+ @max_nesting = opts[:max_nesting]
+ else
+ @max_nesting = 0
+ end
+ self
+ end
+
+ # Returns the configuration instance variables as a hash, that can be
+ # passed to the configure method.
+ def to_h
+ result = {}
+ for iv in %w[indent space space_before object_nl array_nl check_circular allow_nan max_nesting]
+ result[iv.intern] = instance_variable_get("@#{iv}")
+ end
+ result
+ end
+ end
+
+ module GeneratorMethods
+ module Object
+ # Converts this object to a string (calling #to_s), converts
+ # it to a JSON string, and returns the result. This is a fallback, if no
+ # special method #to_json was defined for some object.
+ def to_json(*) to_s.to_json end
+ end
+
+ module Hash
+ # Returns a JSON string containing a JSON object, that is unparsed from
+ # this Hash instance.
+ # _state_ is a JSON::State object, that can also be used to configure the
+ # produced JSON string output further.
+ # _depth_ is used to find out nesting depth, to indent accordingly.
+ def to_json(state = nil, depth = 0, *)
+ if state
+ state = JSON.state.from_state(state)
+ state.check_max_nesting(depth)
+ json_check_circular(state) { json_transform(state, depth) }
+ else
+ json_transform(state, depth)
+ end
+ end
+
+ private
+
+ def json_check_circular(state)
+ if state and state.check_circular?
+ state.seen?(self) and raise JSON::CircularDatastructure,
+ "circular data structures not supported!"
+ state.remember self
+ end
+ yield
+ ensure
+ state and state.forget self
+ end
+
+ def json_shift(state, depth)
+ state and not state.object_nl.empty? or return ''
+ state.indent * depth
+ end
+
+ def json_transform(state, depth)
+ delim = ','
+ delim << state.object_nl if state
+ result = '{'
+ result << state.object_nl if state
+ result << map { |key,value|
+ s = json_shift(state, depth + 1)
+ s << key.to_s.to_json(state, depth + 1)
+ s << state.space_before if state
+ s << ':'
+ s << state.space if state
+ s << value.to_json(state, depth + 1)
+ }.join(delim)
+ result << state.object_nl if state
+ result << json_shift(state, depth)
+ result << '}'
+ result
+ end
+ end
+
+ module Array
+ # Returns a JSON string containing a JSON array, that is unparsed from
+ # this Array instance.
+ # _state_ is a JSON::State object, that can also be used to configure the
+ # produced JSON string output further.
+ # _depth_ is used to find out nesting depth, to indent accordingly.
+ def to_json(state = nil, depth = 0, *)
+ if state
+ state = JSON.state.from_state(state)
+ state.check_max_nesting(depth)
+ json_check_circular(state) { json_transform(state, depth) }
+ else
+ json_transform(state, depth)
+ end
+ end
+
+ private
+
+ def json_check_circular(state)
+ if state and state.check_circular?
+ state.seen?(self) and raise JSON::CircularDatastructure,
+ "circular data structures not supported!"
+ state.remember self
+ end
+ yield
+ ensure
+ state and state.forget self
+ end
+
+ def json_shift(state, depth)
+ state and not state.array_nl.empty? or return ''
+ state.indent * depth
+ end
+
+ def json_transform(state, depth)
+ delim = ','
+ delim << state.array_nl if state
+ result = '['
+ result << state.array_nl if state
+ result << map { |value|
+ json_shift(state, depth + 1) << value.to_json(state, depth + 1)
+ }.join(delim)
+ result << state.array_nl if state
+ result << json_shift(state, depth)
+ result << ']'
+ result
+ end
+ end
+
+ module Integer
+ # Returns a JSON string representation for this Integer number.
+ def to_json(*) to_s end
+ end
+
+ module Float
+ # Returns a JSON string representation for this Float number.
+ def to_json(state = nil, *)
+ case
+ when infinite?
+ if !state || state.allow_nan?
+ to_s
+ else
+ raise GeneratorError, "#{self} not allowed in JSON"
+ end
+ when nan?
+ if !state || state.allow_nan?
+ to_s
+ else
+ raise GeneratorError, "#{self} not allowed in JSON"
+ end
+ else
+ to_s
+ end
+ end
+ end
+
+ module String
+ # This string should be encoded with UTF-8 A call to this method
+ # returns a JSON string encoded with UTF16 big endian characters as
+ # \u????.
+ def to_json(*)
+ '"' << JSON.utf8_to_json(self) << '"'
+ end
+
+ # Module that holds the extinding methods if, the String module is
+ # included.
+ module Extend
+ # Raw Strings are JSON Objects (the raw bytes are stored in an array for the
+ # key "raw"). The Ruby String can be created by this module method.
+ def json_create(o)
+ o['raw'].pack('C*')
+ end
+ end
+
+ # Extends _modul_ with the String::Extend module.
+ def self.included(modul)
+ modul.extend Extend
+ end
+
+ # This method creates a raw object hash, that can be nested into
+ # other data structures and will be unparsed as a raw string. This
+ # method should be used, if you want to convert raw strings to JSON
+ # instead of UTF-8 strings, e. g. binary data.
+ def to_json_raw_object
+ {
+ JSON.create_id => self.class.name,
+ 'raw' => self.unpack('C*'),
+ }
+ end
+
+ # This method creates a JSON text from the result of
+ # a call to to_json_raw_object of this String.
+ def to_json_raw(*args)
+ to_json_raw_object.to_json(*args)
+ end
+ end
+
+ module TrueClass
+ # Returns a JSON string for true: 'true'.
+ def to_json(*) 'true' end
+ end
+
+ module FalseClass
+ # Returns a JSON string for false: 'false'.
+ def to_json(*) 'false' end
+ end
+
+ module NilClass
+ # Returns a JSON string for nil: 'null'.
+ def to_json(*) 'null' end
+ end
+ end
+ end
+ end
+end
--- /dev/null
+require 'strscan'
+
+module JSON
+ module Pure
+ # This class implements the JSON parser that is used to parse a JSON string
+ # into a Ruby data structure.
+ class Parser < StringScanner
+ STRING = /" ((?:[^\x0-\x1f"\\] |
+ \\["\\\/bfnrt] |
+ \\u[0-9a-fA-F]{4} |
+ \\[\x20-\xff])*)
+ "/nx
+ INTEGER = /(-?0|-?[1-9]\d*)/
+ FLOAT = /(-?
+ (?:0|[1-9]\d*)
+ (?:
+ \.\d+(?i:e[+-]?\d+) |
+ \.\d+ |
+ (?i:e[+-]?\d+)
+ )
+ )/x
+ NAN = /NaN/
+ INFINITY = /Infinity/
+ MINUS_INFINITY = /-Infinity/
+ OBJECT_OPEN = /\{/
+ OBJECT_CLOSE = /\}/
+ ARRAY_OPEN = /\[/
+ ARRAY_CLOSE = /\]/
+ PAIR_DELIMITER = /:/
+ COLLECTION_DELIMITER = /,/
+ TRUE = /true/
+ FALSE = /false/
+ NULL = /null/
+ IGNORE = %r(
+ (?:
+ //[^\n\r]*[\n\r]| # line comments
+ /\* # c-style comments
+ (?:
+ [^*/]| # normal chars
+ /[^*]| # slashes that do not start a nested comment
+ \*[^/]| # asterisks that do not end this comment
+ /(?=\*/) # single slash before this comment's end
+ )*
+ \*/ # the End of this comment
+ |[ \t\r\n]+ # whitespaces: space, horicontal tab, lf, cr
+ )+
+ )mx
+
+ UNPARSED = Object.new
+
+ # Creates a new JSON::Pure::Parser instance for the string _source_.
+ #
+ # It will be configured by the _opts_ hash. _opts_ can have the following
+ # keys:
+ # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+ # structures. Disable depth checking with :max_nesting => false|nil|0,
+ # it defaults to 19.
+ # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+ # defiance of RFC 4627 to be parsed by the Parser. This option defaults
+ # to false.
+ # * *create_additions*: If set to false, the Parser doesn't create
+ # additions even if a matchin class and create_id was found. This option
+ # defaults to true.
+ def initialize(source, opts = {})
+ super
+ if !opts.key?(:max_nesting) # defaults to 19
+ @max_nesting = 19
+ elsif opts[:max_nesting]
+ @max_nesting = opts[:max_nesting]
+ else
+ @max_nesting = 0
+ end
+ @allow_nan = !!opts[:allow_nan]
+ ca = true
+ ca = opts[:create_additions] if opts.key?(:create_additions)
+ @create_id = ca ? JSON.create_id : nil
+ end
+
+ alias source string
+
+ # Parses the current JSON string _source_ and returns the complete data
+ # structure as a result.
+ def parse
+ reset
+ obj = nil
+ until eos?
+ case
+ when scan(OBJECT_OPEN)
+ obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+ @current_nesting = 1
+ obj = parse_object
+ when scan(ARRAY_OPEN)
+ obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
+ @current_nesting = 1
+ obj = parse_array
+ when skip(IGNORE)
+ ;
+ else
+ raise ParserError, "source '#{peek(20)}' not in JSON!"
+ end
+ end
+ obj or raise ParserError, "source did not contain any JSON!"
+ obj
+ end
+
+ private
+
+ # Unescape characters in strings.
+ UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+ UNESCAPE_MAP.update({
+ ?" => '"',
+ ?\\ => '\\',
+ ?/ => '/',
+ ?b => "\b",
+ ?f => "\f",
+ ?n => "\n",
+ ?r => "\r",
+ ?t => "\t",
+ ?u => nil,
+ })
+
+ def parse_string
+ if scan(STRING)
+ return '' if self[1].empty?
+ self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+ if u = UNESCAPE_MAP[$&[1]]
+ u
+ else # \uXXXX
+ res = []
+ stack = nil
+ [c.delete!('\\\\u')].pack("H*").unpack("n*").each do |c|
+ case c
+ when 0xD800..0xDBFF
+ raise JSON::ParserError, "partial character in source" if stack
+ stack = c
+ when 0xDC00..0xDFFF
+ raise JSON::ParserError,
+ "partial character in source" unless (0xD800..0xDBFF).include?(stack)
+ res << (stack << 10) - 0x35fdc00 + c
+ stack = nil
+ else
+ raise JSON::ParserError, "partial character in source" if stack
+ res << c
+ end
+ end
+ raise JSON::ParserError, "partial character in source" if stack
+ res.pack("U*")
+ end
+ end.force_encoding("UTF-8")
+ else
+ UNPARSED
+ end
+ end
+
+ def parse_value
+ case
+ when scan(FLOAT)
+ Float(self[1])
+ when scan(INTEGER)
+ Integer(self[1])
+ when scan(TRUE)
+ true
+ when scan(FALSE)
+ false
+ when scan(NULL)
+ nil
+ when (string = parse_string) != UNPARSED
+ string
+ when scan(ARRAY_OPEN)
+ @current_nesting += 1
+ ary = parse_array
+ @current_nesting -= 1
+ ary
+ when scan(OBJECT_OPEN)
+ @current_nesting += 1
+ obj = parse_object
+ @current_nesting -= 1
+ obj
+ when @allow_nan && scan(NAN)
+ NaN
+ when @allow_nan && scan(INFINITY)
+ Infinity
+ when @allow_nan && scan(MINUS_INFINITY)
+ MinusInfinity
+ else
+ UNPARSED
+ end
+ end
+
+ def parse_array
+ raise NestingError, "nesting of #@current_nesting is to deep" if
+ @max_nesting.nonzero? && @current_nesting > @max_nesting
+ result = []
+ delim = false
+ until eos?
+ case
+ when (value = parse_value) != UNPARSED
+ delim = false
+ result << value
+ skip(IGNORE)
+ if scan(COLLECTION_DELIMITER)
+ delim = true
+ elsif match?(ARRAY_CLOSE)
+ ;
+ else
+ raise ParserError, "expected ',' or ']' in array at '#{peek(20)}'!"
+ end
+ when scan(ARRAY_CLOSE)
+ if delim
+ raise ParserError, "expected next element in array at '#{peek(20)}'!"
+ end
+ break
+ when skip(IGNORE)
+ ;
+ else
+ raise ParserError, "unexpected token in array at '#{peek(20)}'!"
+ end
+ end
+ result
+ end
+
+ def parse_object
+ raise NestingError, "nesting of #@current_nesting is to deep" if
+ @max_nesting.nonzero? && @current_nesting > @max_nesting
+ result = {}
+ delim = false
+ until eos?
+ case
+ when (string = parse_string) != UNPARSED
+ skip(IGNORE)
+ unless scan(PAIR_DELIMITER)
+ raise ParserError, "expected ':' in object at '#{peek(20)}'!"
+ end
+ skip(IGNORE)
+ unless (value = parse_value).equal? UNPARSED
+ result[string] = value
+ delim = false
+ skip(IGNORE)
+ if scan(COLLECTION_DELIMITER)
+ delim = true
+ elsif match?(OBJECT_CLOSE)
+ ;
+ else
+ raise ParserError, "expected ',' or '}' in object at '#{peek(20)}'!"
+ end
+ else
+ raise ParserError, "expected value in object at '#{peek(20)}'!"
+ end
+ when scan(OBJECT_CLOSE)
+ if delim
+ raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
+ end
+ if @create_id and klassname = result[@create_id]
+ klass = JSON.deep_const_get klassname
+ break unless klass and klass.json_creatable?
+ result = klass.json_create(result)
+ end
+ break
+ when skip(IGNORE)
+ ;
+ else
+ raise ParserError, "unexpected token in object at '#{peek(20)}'!"
+ end
+ end
+ result
+ end
+ end
+ end
+end
--- /dev/null
+module JSON
+ # JSON version
+ VERSION = '1.1.3'
+ VERSION_ARRAY = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+ VERSION_MAJOR = VERSION_ARRAY[0] # :nodoc:
+ VERSION_MINOR = VERSION_ARRAY[1] # :nodoc:
+ VERSION_BUILD = VERSION_ARRAY[2] # :nodoc:
+ VARIANT_BINARY = false
+end
--- /dev/null
+#
+# kconv.rb - Kanji Converter.
+#
+# $Id: kconv.rb 15050 2008-01-14 14:37:29Z naruse $
+#
+# ----
+#
+# kconv.rb implements the Kconv class for Kanji Converter. Additionally,
+# some methods in String classes are added to allow easy conversion.
+#
+
+require 'nkf'
+
+#
+# Kanji Converter for Ruby.
+#
+module Kconv
+ #
+ # Public Constants
+ #
+
+ #Constant of Encoding
+
+ # Auto-Detect
+ AUTO = NKF::AUTO
+ # ISO-2022-JP
+ JIS = NKF::JIS
+ # EUC-JP
+ EUC = NKF::EUC
+ # Shift_JIS
+ SJIS = NKF::SJIS
+ # BINARY
+ BINARY = NKF::BINARY
+ # NOCONV
+ NOCONV = NKF::NOCONV
+ # ASCII
+ ASCII = NKF::ASCII
+ # UTF-8
+ UTF8 = NKF::UTF8
+ # UTF-16
+ UTF16 = NKF::UTF16
+ # UTF-32
+ UTF32 = NKF::UTF32
+ # UNKNOWN
+ UNKNOWN = NKF::UNKNOWN
+
+ #
+ # Public Methods
+ #
+
+ # call-seq:
+ # Kconv.kconv(str, to_enc, from_enc=nil)
+ #
+ # Convert <code>str</code> to out_code.
+ # <code>out_code</code> and <code>in_code</code> are given as constants of Kconv.
+ def kconv(str, to_enc, from_enc=nil)
+ opt = ''
+ opt += ' --ic=' + from_enc.to_s if from_enc
+ opt += ' --oc=' + to_enc.to_s if to_enc
+
+ ::NKF::nkf(opt, str)
+ end
+ module_function :kconv
+
+ #
+ # Encode to
+ #
+
+ # call-seq:
+ # Kconv.tojis(str) => string
+ #
+ # Convert <code>str</code> to ISO-2022-JP
+ def tojis(str)
+ kconv(str, JIS)
+ end
+ module_function :tojis
+
+ # call-seq:
+ # Kconv.toeuc(str) => string
+ #
+ # Convert <code>str</code> to EUC-JP
+ def toeuc(str)
+ kconv(str, EUC)
+ end
+ module_function :toeuc
+
+ # call-seq:
+ # Kconv.tosjis(str) => string
+ #
+ # Convert <code>str</code> to Shift_JIS
+ def tosjis(str)
+ kconv(str, SJIS)
+ end
+ module_function :tosjis
+
+ # call-seq:
+ # Kconv.toutf8(str) => string
+ #
+ # Convert <code>str</code> to UTF-8
+ def toutf8(str)
+ kconv(str, UTF8)
+ end
+ module_function :toutf8
+
+ # call-seq:
+ # Kconv.toutf16(str) => string
+ #
+ # Convert <code>str</code> to UTF-16
+ def toutf16(str)
+ kconv(str, UTF16)
+ end
+ module_function :toutf16
+
+ # call-seq:
+ # Kconv.toutf32(str) => string
+ #
+ # Convert <code>str</code> to UTF-32
+ def toutf32(str)
+ kconv(str, UTF32)
+ end
+ module_function :toutf32
+
+ # call-seq:
+ # Kconv.tolocale => string
+ #
+ # Convert <code>self</code> to locale encoding
+ def tolocale(str)
+ kconv(str, Encoding.locale_charmap)
+ end
+ module_function :tolocale
+
+ #
+ # guess
+ #
+
+ # call-seq:
+ # Kconv.guess(str) => encoding
+ #
+ # Guess input encoding by NKF.guess
+ def guess(str)
+ ::NKF::guess(str)
+ end
+ module_function :guess
+
+ #
+ # isEncoding
+ #
+
+ # call-seq:
+ # Kconv.iseuc(str) => true or false
+ #
+ # Returns whether input encoding is EUC-JP or not.
+ #
+ # *Note* don't expect this return value is MatchData.
+ def iseuc(str)
+ str.dup.force_encoding(EUC).valid_encoding?
+ end
+ module_function :iseuc
+
+ # call-seq:
+ # Kconv.issjis(str) => true or false
+ #
+ # Returns whether input encoding is Shift_JIS or not.
+ def issjis(str)
+ str.dup.force_encoding(SJIS).valid_encoding?
+ end
+ module_function :issjis
+
+ # call-seq:
+ # Kconv.isjis(str) => true or false
+ #
+ # Returns whether input encoding is ISO-2022-JP or not.
+ def isjis(str)
+ /\A [\t\n\r\x20-\x7E]*
+ (?:
+ (?:\x1b \x28 I [\x21-\x7E]*
+ |\x1b \x28 J [\x21-\x7E]*
+ |\x1b \x24 @ (?:[\x21-\x7E]{2})*
+ |\x1b \x24 B (?:[\x21-\x7E]{2})*
+ |\x1b \x24 \x28 D (?:[\x21-\x7E]{2})*
+ )*
+ \x1b \x28 B [\t\n\r\x20-\x7E]*
+ )*
+ \z/nox =~ str.dup.force_encoding('BINARY') ? true : false
+ end
+ module_function :isjis
+
+ # call-seq:
+ # Kconv.isutf8(str) => true or false
+ #
+ # Returns whether input encoding is UTF-8 or not.
+ def isutf8(str)
+ str.dup.force_encoding(UTF8).valid_encoding?
+ end
+ module_function :isutf8
+end
+
+class String
+ # call-seq:
+ # String#kconv(to_enc, from_enc)
+ #
+ # Convert <code>self</code> to out_code.
+ # <code>out_code</code> and <code>in_code</code> are given as constants of Kconv.
+ def kconv(to_enc, from_enc=nil)
+ form_enc = self.encoding if !from_enc && self.encoding != Encoding.list[0]
+ Kconv::kconv(self, to_enc, from_enc)
+ end
+
+ #
+ # to Encoding
+ #
+
+ # call-seq:
+ # String#tojis => string
+ #
+ # Convert <code>self</code> to ISO-2022-JP
+ def tojis; Kconv.tojis(self) end
+
+ # call-seq:
+ # String#toeuc => string
+ #
+ # Convert <code>self</code> to EUC-JP
+ def toeuc; Kconv.toeuc(self) end
+
+ # call-seq:
+ # String#tosjis => string
+ #
+ # Convert <code>self</code> to Shift_JIS
+ def tosjis; Kconv.tosjis(self) end
+
+ # call-seq:
+ # String#toutf8 => string
+ #
+ # Convert <code>self</code> to UTF-8
+ def toutf8; Kconv.toutf8(self) end
+
+ # call-seq:
+ # String#toutf16 => string
+ #
+ # Convert <code>self</code> to UTF-16
+ def toutf16; Kconv.toutf16(self) end
+
+ # call-seq:
+ # String#toutf32 => string
+ #
+ # Convert <code>self</code> to UTF-32
+ def toutf32; Kconv.toutf32(self) end
+
+ # call-seq:
+ # String#tolocale => string
+ #
+ # Convert <code>self</code> to locale encoding
+ def tolocale; Kconv.tolocale(self) end
+
+ #
+ # is Encoding
+ #
+
+ # call-seq:
+ # String#iseuc => true or false
+ #
+ # Returns whether <code>self</code>'s encoding is EUC-JP or not.
+ def iseuc; Kconv.iseuc(self) end
+
+ # call-seq:
+ # String#issjis => true or false
+ #
+ # Returns whether <code>self</code>'s encoding is Shift_JIS or not.
+ def issjis; Kconv.issjis(self) end
+
+ # call-seq:
+ # String#isjis => true or false
+ #
+ # Returns whether <code>self</code>'s encoding is ISO-2022-JP or not.
+ def isjis; Kconv.isjis(self) end
+
+ # call-seq:
+ # String#isutf8 => true or false
+ #
+ # Returns whether <code>self</code>'s encoding is UTF-8 or not.
+ def isutf8; Kconv.isutf8(self) end
+end
--- /dev/null
+=begin
+= $RCSfile$ -- Loader for all OpenSSL C-space and Ruby-space definitions
+
+= Info
+ 'OpenSSL for Ruby 2' project
+ Copyright (C) 2002 Michal Rokos <m.rokos@sh.cvut.cz>
+ All rights reserved.
+
+= Licence
+ This program is licenced under the same licence as Ruby.
+ (See the file 'LICENCE'.)
+
+= Version
+ $Id: openssl.rb 11708 2007-02-12 23:01:19Z shyouhei $
+=end
+
+require 'openssl.so'
+
+require 'openssl/bn'
+require 'openssl/cipher'
+require 'openssl/digest'
+require 'openssl/ssl'
+require 'openssl/x509'
+
--- /dev/null
+=begin
+= $RCSfile$ -- Ruby-space definitions that completes C-space funcs for BN
+
+= Info
+ 'OpenSSL for Ruby 2' project
+ Copyright (C) 2002 Michal Rokos <m.rokos@sh.cvut.cz>
+ All rights reserved.
+
+= Licence
+ This program is licenced under the same licence as Ruby.
+ (See the file 'LICENCE'.)
+
+= Version
+ $Id: bn.rb 11708 2007-02-12 23:01:19Z shyouhei $
+=end
+
+##
+# Should we care what if somebody require this file directly?
+#require 'openssl'
+
+module OpenSSL
+ class BN
+ include Comparable
+ end # BN
+end # OpenSSL
+
+##
+# Add double dispatch to Integer
+#
+class Integer
+ def to_bn
+ OpenSSL::BN::new(self)
+ end
+end # Integer
+
--- /dev/null
+=begin
+= $RCSfile$ -- Buffering mix-in module.
+
+= Info
+ 'OpenSSL for Ruby 2' project
+ Copyright (C) 2001 GOTOU YUUZOU <gotoyuzo@notwork.org>
+ All rights reserved.
+
+= Licence
+ This program is licenced under the same licence as Ruby.
+ (See the file 'LICENCE'.)
+
+= Version
+ $Id: buffering.rb 14261 2007-12-17 07:06:16Z gotoyuzo $
+=end
+
+module Buffering
+ include Enumerable
+ attr_accessor :sync
+ BLOCK_SIZE = 1024*16
+
+ def initialize(*args)
+ @eof = false
+ @rbuffer = ""
+ @sync = @io.sync
+ end
+
+ #
+ # for reading.
+ #
+ private
+
+ def fill_rbuff
+ begin
+ @rbuffer << self.sysread(BLOCK_SIZE)
+ rescue Errno::EAGAIN
+ retry
+ rescue EOFError
+ @eof = true
+ end
+ end
+
+ def consume_rbuff(size=nil)
+ if @rbuffer.empty?
+ nil
+ else
+ size = @rbuffer.size unless size
+ ret = @rbuffer[0, size]
+ @rbuffer[0, size] = ""
+ ret
+ end
+ end
+
+ public
+
+ def read(size=nil, buf=nil)
+ if size == 0
+ if buf
+ buf.clear
+ return buf
+ else
+ return ""
+ end
+ end
+ until @eof
+ break if size && size <= @rbuffer.size
+ fill_rbuff
+ end
+ ret = consume_rbuff(size) || ""
+ if buf
+ buf.replace(ret)
+ ret = buf
+ end
+ (size && ret.empty?) ? nil : ret
+ end
+
+ def readpartial(maxlen, buf=nil)
+ if maxlen == 0
+ if buf
+ buf.clear
+ return buf
+ else
+ return ""
+ end
+ end
+ if @rbuffer.empty?
+ begin
+ return sysread(maxlen, buf)
+ rescue Errno::EAGAIN
+ retry
+ end
+ end
+ ret = consume_rbuff(maxlen)
+ if buf
+ buf.replace(ret)
+ ret = buf
+ end
+ raise EOFError if ret.empty?
+ ret
+ end
+
+ def gets(eol=$/, limit=nil)
+ idx = @rbuffer.index(eol)
+ until @eof
+ break if idx
+ fill_rbuff
+ idx = @rbuffer.index(eol)
+ end
+ if eol.is_a?(Regexp)
+ size = idx ? idx+$&.size : nil
+ else
+ size = idx ? idx+eol.size : nil
+ end
+ if limit and limit >= 0
+ size = [size, limit].min
+ end
+ consume_rbuff(size)
+ end
+
+ def each(eol=$/)
+ while line = self.gets(eol)
+ yield line
+ end
+ end
+ alias each_line each
+
+ def readlines(eol=$/)
+ ary = []
+ while line = self.gets(eol)
+ ary << line
+ end
+ ary
+ end
+
+ def readline(eol=$/)
+ raise EOFError if eof?
+ gets(eol)
+ end
+
+ def getc
+ c = read(1)
+ c ? c[0] : nil
+ end
+
+ def each_byte
+ while c = getc
+ yield(c)
+ end
+ end
+
+ def readchar
+ raise EOFError if eof?
+ getc
+ end
+
+ def ungetc(c)
+ @rbuffer[0,0] = c.chr
+ end
+
+ def eof?
+ fill_rbuff if !@eof && @rbuffer.empty?
+ @eof && @rbuffer.empty?
+ end
+ alias eof eof?
+
+ #
+ # for writing.
+ #
+ private
+
+ def do_write(s)
+ @wbuffer = "" unless defined? @wbuffer
+ @wbuffer << s
+ @sync ||= false
+ if @sync or @wbuffer.size > BLOCK_SIZE or idx = @wbuffer.rindex($/)
+ remain = idx ? idx + $/.size : @wbuffer.length
+ nwritten = 0
+ while remain > 0
+ str = @wbuffer[nwritten,remain]
+ begin
+ nwrote = syswrite(str)
+ rescue Errno::EAGAIN
+ retry
+ end
+ remain -= nwrote
+ nwritten += nwrote
+ end
+ @wbuffer[0,nwritten] = ""
+ end
+ end
+
+ public
+
+ def write(s)
+ do_write(s)
+ s.length
+ end
+
+ def << (s)
+ do_write(s)
+ self
+ end
+
+ def puts(*args)
+ s = ""
+ if args.empty?
+ s << "\n"
+ end
+ args.each{|arg|
+ s << arg.to_s
+ if $/ && /\n\z/ !~ s
+ s << "\n"
+ end
+ }
+ do_write(s)
+ nil
+ end
+
+ def print(*args)
+ s = ""
+ args.each{ |arg| s << arg.to_s }
+ do_write(s)
+ nil
+ end
+
+ def printf(s, *args)
+ do_write(s % args)
+ nil
+ end
+
+ def flush
+ osync = @sync
+ @sync = true
+ do_write ""
+ @sync = osync
+ end
+
+ def close
+ flush rescue nil
+ sysclose
+ end
+end
--- /dev/null
+=begin
+= $RCSfile$ -- Ruby-space predefined Cipher subclasses
+
+= Info
+ 'OpenSSL for Ruby 2' project
+ Copyright (C) 2002 Michal Rokos <m.rokos@sh.cvut.cz>
+ All rights reserved.
+
+= Licence
+ This program is licenced under the same licence as Ruby.
+ (See the file 'LICENCE'.)
+
+= Version
+ $Id: cipher.rb 12148 2007-04-05 05:59:22Z technorama $
+=end
+
+##
+# Should we care what if somebody require this file directly?
+#require 'openssl'
+
+module OpenSSL
+ class Cipher
+ %w(AES CAST5 BF DES IDEA RC2 RC4 RC5).each{|name|
+ klass = Class.new(Cipher){
+ define_method(:initialize){|*args|
+ cipher_name = args.inject(name){|n, arg| "#{n}-#{arg}" }
+ super(cipher_name)
+ }
+ }
+ const_set(name, klass)
+ }
+
+ %w(128 192 256).each{|keylen|
+ klass = Class.new(Cipher){
+ define_method(:initialize){|mode|
+ mode ||= "CBC"
+ cipher_name = "AES-#{keylen}-#{mode}"
+ super(cipher_name)
+ }
+ }
+ const_set("AES#{keylen}", klass)
+ }
+
+ # Generate, set, and return a random key.
+ # You must call cipher.encrypt or cipher.decrypt before calling this method.
+ def random_key
+ str = OpenSSL::Random.random_bytes(self.key_len)
+ self.key = str
+ return str
+ end
+
+ # Generate, set, and return a random iv.
+ # You must call cipher.encrypt or cipher.decrypt before calling this method.
+ def random_iv
+ str = OpenSSL::Random.random_bytes(self.iv_len)
+ self.iv = str
+ return str
+ end
+
+ # This class is only provided for backwards compatibility. Use OpenSSL::Digest in the future.
+ class Cipher < Cipher
+ # add warning
+ end
+ end # Cipher
+end # OpenSSL
--- /dev/null
+=begin
+= $RCSfile$ -- Ruby-space predefined Digest subclasses
+
+= Info
+ 'OpenSSL for Ruby 2' project
+ Copyright (C) 2002 Michal Rokos <m.rokos@sh.cvut.cz>
+ All rights reserved.
+
+= Licence
+ This program is licenced under the same licence as Ruby.
+ (See the file 'LICENCE'.)
+
+= Version
+ $Id: digest.rb 15602 2008-02-25 08:51:18Z technorama $
+=end
+
+##
+# Should we care what if somebody require this file directly?
+#require 'openssl'
+
+module OpenSSL
+ class Digest
+
+ alg = %w(DSS DSS1 MD2 MD4 MD5 MDC2 RIPEMD160 SHA SHA1)
+ if OPENSSL_VERSION_NUMBER > 0x00908000
+ alg += %w(SHA224 SHA256 SHA384 SHA512)
+ end
+
+ def self.digest(name, data)
+ super(data, name)
+ end
+
+ alg.each{|name|
+ klass = Class.new(Digest){
+ define_method(:initialize){|*data|
+ if data.length > 1
+ raise ArgumentError,
+ "wrong number of arguments (#{data.length} for 1)"
+ end
+ super(name, data.first)
+ }
+ }
+ singleton = (class <<klass; self; end)
+ singleton.class_eval{
+ define_method(:digest){|data| Digest.digest(name, data) }
+ define_method(:hexdigest){|data| Digest.hexdigest(name, data) }
+ }
+ const_set(name, klass)
+ }
+
+ # This class is only provided for backwards compatibility. Use OpenSSL::Digest in the future.
+ class Digest < Digest
+ def initialize(*args)
+ # add warning
+ super(*args)
+ end
+ end
+
+ end # Digest
+end # OpenSSL
+
--- /dev/null
+=begin
+= $RCSfile$ -- Ruby-space definitions that completes C-space funcs for SSL
+
+= Info
+ 'OpenSSL for Ruby 2' project
+ Copyright (C) 2001 GOTOU YUUZOU <gotoyuzo@notwork.org>
+ All rights reserved.
+
+= Licence
+ This program is licenced under the same licence as Ruby.
+ (See the file 'LICENCE'.)
+
+= Version
+ $Id: ssl.rb 14479 2007-12-22 08:31:53Z gotoyuzo $
+=end
+
+require "openssl"
+require "openssl/buffering"
+require "fcntl"
+
+module OpenSSL
+ module SSL
+ class SSLContext
+ DEFAULT_PARAMS = {
+ :ssl_version => "SSLv23",
+ :verify_mode => OpenSSL::SSL::VERIFY_PEER,
+ :ciphers => "ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW",
+ :options => OpenSSL::SSL::OP_ALL,
+ }
+
+ DEFAULT_CERT_STORE = OpenSSL::X509::Store.new
+ DEFAULT_CERT_STORE.set_default_paths
+ if defined?(OpenSSL::X509::V_FLAG_CRL_CHECK_ALL)
+ DEFAULT_CERT_STORE.flags = OpenSSL::X509::V_FLAG_CRL_CHECK_ALL
+ end
+
+ def set_params(params={})
+ params = DEFAULT_PARAMS.merge(params)
+ params.each{|name, value| self.__send__("#{name}=", value) }
+ if self.verify_mode != OpenSSL::SSL::VERIFY_NONE
+ unless self.ca_file or self.ca_path or self.cert_store
+ self.cert_store = DEFAULT_CERT_STORE
+ end
+ end
+ return params
+ end
+ end
+
+ module SocketForwarder
+ def addr
+ to_io.addr
+ end
+
+ def peeraddr
+ to_io.peeraddr
+ end
+
+ def setsockopt(level, optname, optval)
+ to_io.setsockopt(level, optname, optval)
+ end
+
+ def getsockopt(level, optname)
+ to_io.getsockopt(level, optname)
+ end
+
+ def fcntl(*args)
+ to_io.fcntl(*args)
+ end
+
+ def closed?
+ to_io.closed?
+ end
+
+ def do_not_reverse_lookup=(flag)
+ to_io.do_not_reverse_lookup = flag
+ end
+ end
+
+ module Nonblock
+ def initialize(*args)
+ flag = File::NONBLOCK
+ flag |= @io.fcntl(Fcntl::F_GETFL) if defined?(Fcntl::F_GETFL)
+ @io.fcntl(Fcntl::F_SETFL, flag)
+ super
+ end
+ end
+
+ def verify_certificate_identity(cert, hostname)
+ should_verify_common_name = true
+ cert.extensions.each{|ext|
+ next if ext.oid != "subjectAltName"
+ ext.value.split(/,\s+/).each{|general_name|
+ if /\ADNS:(.*)/ =~ general_name
+ should_verify_common_name = false
+ reg = Regexp.escape($1).gsub(/\\\*/, "[^.]+")
+ return true if /\A#{reg}\z/i =~ hostname
+ elsif /\AIP Address:(.*)/ =~ general_name
+ should_verify_common_name = false
+ return true if $1 == hostname
+ end
+ }
+ }
+ if should_verify_common_name
+ cert.subject.to_a.each{|oid, value|
+ if oid == "CN"
+ reg = Regexp.escape(value).gsub(/\\\*/, "[^.]+")
+ return true if /\A#{reg}\z/i =~ hostname
+ end
+ }
+ end
+ return false
+ end
+ module_function :verify_certificate_identity
+
+ class SSLSocket
+ include Buffering
+ include SocketForwarder
+ include Nonblock
+
+ def post_connection_check(hostname)
+ unless OpenSSL::SSL.verify_certificate_identity(peer_cert, hostname)
+ raise SSLError, "hostname was not match with the server certificate"
+ end
+ return true
+ end
+
+ def session
+ SSL::Session.new(self)
+ rescue SSL::Session::SessionError
+ nil
+ end
+ end
+
+ class SSLServer
+ include SocketForwarder
+ attr_accessor :start_immediately
+
+ def initialize(svr, ctx)
+ @svr = svr
+ @ctx = ctx
+ unless ctx.session_id_context
+ session_id = OpenSSL::Digest::MD5.hexdigest($0)
+ @ctx.session_id_context = session_id
+ end
+ @start_immediately = true
+ end
+
+ def to_io
+ @svr
+ end
+
+ def listen(backlog=5)
+ @svr.listen(backlog)
+ end
+
+ def shutdown(how=Socket::SHUT_RDWR)
+ @svr.shutdown(how)
+ end
+
+ def accept
+ sock = @svr.accept
+ begin
+ ssl = OpenSSL::SSL::SSLSocket.new(sock, @ctx)
+ ssl.sync_close = true
+ ssl.accept if @start_immediately
+ ssl
+ rescue SSLError => ex
+ sock.close
+ raise ex
+ end
+ end
+
+ def close
+ @svr.close
+ end
+ end
+ end
+end
--- /dev/null
+=begin
+= $RCSfile$ -- Ruby-space definitions that completes C-space funcs for X509 and subclasses
+
+= Info
+ 'OpenSSL for Ruby 2' project
+ Copyright (C) 2002 Michal Rokos <m.rokos@sh.cvut.cz>
+ All rights reserved.
+
+= Licence
+ This program is licenced under the same licence as Ruby.
+ (See the file 'LICENCE'.)
+
+= Version
+ $Id: x509.rb 15442 2008-02-12 06:18:06Z naruse $
+=end
+
+require "openssl"
+
+module OpenSSL
+ module X509
+ class ExtensionFactory
+ def create_extension(*arg)
+ if arg.size > 1
+ create_ext(*arg)
+ else
+ send("create_ext_from_"+arg[0].class.name.downcase, arg[0])
+ end
+ end
+
+ def create_ext_from_array(ary)
+ raise ExtensionError, "unexpected array form" if ary.size > 3
+ create_ext(ary[0], ary[1], ary[2])
+ end
+
+ def create_ext_from_string(str) # "oid = critical, value"
+ oid, value = str.split(/=/, 2)
+ oid.strip!
+ value.strip!
+ create_ext(oid, value)
+ end
+
+ def create_ext_from_hash(hash)
+ create_ext(hash["oid"], hash["value"], hash["critical"])
+ end
+ end
+
+ class Extension
+ def to_s # "oid = critical, value"
+ str = self.oid
+ str << " = "
+ str << "critical, " if self.critical?
+ str << self.value.gsub(/\n/, ", ")
+ end
+
+ def to_h # {"oid"=>sn|ln, "value"=>value, "critical"=>true|false}
+ {"oid"=>self.oid,"value"=>self.value,"critical"=>self.critical?}
+ end
+
+ def to_a
+ [ self.oid, self.value, self.critical? ]
+ end
+ end
+
+ class Name
+ module RFC2253DN
+ Special = ',=+<>#;'
+ HexChar = /[0-9a-fA-F]/
+ HexPair = /#{HexChar}#{HexChar}/
+ HexString = /#{HexPair}+/
+ Pair = /\\(?:[#{Special}]|\\|"|#{HexPair})/
+ StringChar = /[^#{Special}\\"]/
+ QuoteChar = /[^\\"]/
+ AttributeType = /[a-zA-Z][0-9a-zA-Z]*|[0-9]+(?:\.[0-9]+)*/
+ AttributeValue = /
+ (?!["#])((?:#{StringChar}|#{Pair})*)|
+ \#(#{HexString})|
+ "((?:#{QuoteChar}|#{Pair})*)"
+ /x
+ TypeAndValue = /\A(#{AttributeType})=#{AttributeValue}/
+
+ module_function
+
+ def expand_pair(str)
+ return nil unless str
+ return str.gsub(Pair){
+ pair = $&
+ case pair.size
+ when 2 then pair[1,1]
+ when 3 then Integer("0x#{pair[1,2]}").chr
+ else raise OpenSSL::X509::NameError, "invalid pair: #{str}"
+ end
+ }
+ end
+
+ def expand_hexstring(str)
+ return nil unless str
+ der = str.gsub(HexPair){$&.to_i(16).chr }
+ a1 = OpenSSL::ASN1.decode(der)
+ return a1.value, a1.tag
+ end
+
+ def expand_value(str1, str2, str3)
+ value = expand_pair(str1)
+ value, tag = expand_hexstring(str2) unless value
+ value = expand_pair(str3) unless value
+ return value, tag
+ end
+
+ def scan(dn)
+ str = dn
+ ary = []
+ while true
+ if md = TypeAndValue.match(str)
+ matched = md.to_s
+ remain = md.post_match
+ type = md[1]
+ value, tag = expand_value(md[2], md[3], md[4]) rescue nil
+ if value
+ type_and_value = [type, value]
+ type_and_value.push(tag) if tag
+ ary.unshift(type_and_value)
+ if remain.length > 2 && remain[0] == ?,
+ str = remain[1..-1]
+ next
+ elsif remain.length > 2 && remain[0] == ?+
+ raise OpenSSL::X509::NameError,
+ "multi-valued RDN is not supported: #{dn}"
+ elsif remain.empty?
+ break
+ end
+ end
+ end
+ msg_dn = dn[0, dn.length - str.length] + " =>" + str
+ raise OpenSSL::X509::NameError, "malformed RDN: #{msg_dn}"
+ end
+ return ary
+ end
+ end
+
+ class <<self
+ def parse_rfc2253(str, template=OBJECT_TYPE_TEMPLATE)
+ ary = OpenSSL::X509::Name::RFC2253DN.scan(str)
+ self.new(ary, template)
+ end
+
+ def parse_openssl(str, template=OBJECT_TYPE_TEMPLATE)
+ ary = str.scan(/\s*([^\/,]+)\s*/).collect{|i| i[0].split("=", 2) }
+ self.new(ary, template)
+ end
+
+ alias parse parse_openssl
+ end
+ end
+ end
+end
--- /dev/null
+require 'ripper/core'
+require 'ripper/lexer'
+require 'ripper/filter'
+require 'ripper/sexp'
--- /dev/null
+#
+# $Id: core.rb 11708 2007-02-12 23:01:19Z shyouhei $
+#
+# Copyright (c) 2003-2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute and/or modify this program under the Ruby License.
+# For details of Ruby License, see ruby/COPYING.
+#
+
+require 'ripper.so'
+
+class Ripper
+
+ # Parses Ruby program read from _src_.
+ # _src_ must be a String or a IO or a object which has #gets method.
+ def Ripper.parse(src, filename = '(ripper)', lineno = 1)
+ new(src, filename, lineno).parse
+ end
+
+ # This array contains name of parser events.
+ PARSER_EVENTS = PARSER_EVENT_TABLE.keys
+
+ # This array contains name of scanner events.
+ SCANNER_EVENTS = SCANNER_EVENT_TABLE.keys
+
+ # This array contains name of all ripper events.
+ EVENTS = PARSER_EVENTS + SCANNER_EVENTS
+
+ private
+
+ #
+ # Parser Events
+ #
+
+ PARSER_EVENT_TABLE.each do |id, arity|
+ module_eval(<<-End, __FILE__, __LINE__ + 1)
+ def on_#{id}(#{ ('a'..'z').to_a[0, arity].join(', ') })
+ #{arity == 0 ? 'nil' : 'a'}
+ end
+ End
+ end
+
+ # This method is called when weak warning is produced by the parser.
+ # _fmt_ and _args_ is printf style.
+ def warn(fmt, *args)
+ end
+
+ # This method is called when strong warning is produced by the parser.
+ # _fmt_ and _args_ is printf style.
+ def warning(fmt, *args)
+ end
+
+ # This method is called when the parser found syntax error.
+ def compile_error(msg)
+ end
+
+ #
+ # Scanner Events
+ #
+
+ SCANNER_EVENTS.each do |id|
+ module_eval(<<-End, __FILE__, __LINE__ + 1)
+ def on_#{id}(token)
+ token
+ end
+ End
+ end
+
+end
--- /dev/null
+#
+# $Id: filter.rb 11708 2007-02-12 23:01:19Z shyouhei $
+#
+# Copyright (c) 2004,2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute and/or modify this program under the Ruby License.
+# For details of Ruby License, see ruby/COPYING.
+#
+
+require 'ripper/lexer'
+
+class Ripper
+
+ # This class handles only scanner events,
+ # and they are dispatched in the `right' order (same with input).
+ class Filter
+
+ def initialize(src, filename = '-', lineno = 1)
+ @__lexer = Lexer.new(src, filename, lineno)
+ @__line = nil
+ @__col = nil
+ end
+
+ # The file name of the input.
+ def filename
+ @__lexer.filename
+ end
+
+ # The line number of the current token.
+ # This value starts from 1.
+ # This method is valid only in event handlers.
+ def lineno
+ @__line
+ end
+
+ # The column number of the current token.
+ # This value starts from 0.
+ # This method is valid only in event handlers.
+ def column
+ @__col
+ end
+
+ # Starts parsing. _init_ is a data accumulator.
+ # It is passed to the next event handler (as of Enumerable#inject).
+ def parse(init = nil)
+ data = init
+ @__lexer.lex.each do |pos, event, tok|
+ @__line, @__col = *pos
+ data = if respond_to?(event, true)
+ then __send__(event, tok, data)
+ else on_default(event, tok, data)
+ end
+ end
+ data
+ end
+
+ private
+
+ # This method is called when some event handler have not defined.
+ # _event_ is :on_XXX, _token_ is scanned token, _data_ is a data
+ # accumulator. The return value of this method is passed to the
+ # next event handler (as of Enumerable#inject).
+ def on_default(event, token, data)
+ data
+ end
+
+ end
+
+end
--- /dev/null
+#
+# $Id: lexer.rb 13966 2007-11-19 07:10:09Z matz $
+#
+# Copyright (c) 2004,2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute and/or modify this program under the Ruby License.
+# For details of Ruby License, see ruby/COPYING.
+#
+
+require 'ripper/core'
+
+class Ripper
+
+ # Tokenizes Ruby program and returns an Array of String.
+ def Ripper.tokenize(src, filename = '-', lineno = 1)
+ Lexer.new(src, filename, lineno).tokenize
+ end
+
+ # Tokenizes Ruby program and returns an Array of Array,
+ # which is formatted like [[lineno, column], type, token].
+ #
+ # require 'ripper'
+ # require 'pp'
+ #
+ # p Ripper.lex("def m(a) nil end")
+ # #=> [[[1, 0], :on_kw, "def"],
+ # [[1, 3], :on_sp, " " ],
+ # [[1, 4], :on_ident, "m" ],
+ # [[1, 5], :on_lparen, "(" ],
+ # [[1, 6], :on_ident, "a" ],
+ # [[1, 7], :on_rparen, ")" ],
+ # [[1, 8], :on_sp, " " ],
+ # [[1, 9], :on_kw, "nil"],
+ # [[1, 12], :on_sp, " " ],
+ # [[1, 13], :on_kw, "end"]]
+ #
+ def Ripper.lex(src, filename = '-', lineno = 1)
+ Lexer.new(src, filename, lineno).lex
+ end
+
+ class Lexer < ::Ripper #:nodoc: internal use only
+ def tokenize
+ lex().map {|pos, event, tok| tok }
+ end
+
+ def lex
+ parse().sort_by {|pos, event, tok| pos }
+ end
+
+ def parse
+ @buf = []
+ super
+ @buf
+ end
+
+ private
+
+ SCANNER_EVENTS.each do |event|
+ module_eval(<<-End, __FILE__+'/module_eval', __LINE__ + 1)
+ def on_#{event}(tok)
+ @buf.push [[lineno(), column()], :on_#{event}, tok]
+ end
+ End
+ end
+ end
+
+ # [EXPERIMENTAL]
+ # Parses +src+ and return a string which was matched to +pattern+.
+ # +pattern+ should be described as Regexp.
+ #
+ # require 'ripper'
+ #
+ # p Ripper.slice('def m(a) nil end', 'ident') #=> "m"
+ # p Ripper.slice('def m(a) nil end', '[ident lparen rparen]+') #=> "m(a)"
+ # p Ripper.slice("<<EOS\nstring\nEOS",
+ # 'heredoc_beg nl $(tstring_content*) heredoc_end', 1)
+ # #=> "string\n"
+ #
+ def Ripper.slice(src, pattern, n = 0)
+ if m = token_match(src, pattern)
+ then m.string(n)
+ else nil
+ end
+ end
+
+ def Ripper.token_match(src, pattern) #:nodoc:
+ TokenPattern.compile(pattern).match(src)
+ end
+
+ class TokenPattern #:nodoc:
+
+ class Error < ::StandardError; end
+ class CompileError < Error; end
+ class MatchError < Error; end
+
+ class << self
+ alias compile new
+ end
+
+ def initialize(pattern)
+ @source = pattern
+ @re = compile(pattern)
+ end
+
+ def match(str)
+ match_list(::Ripper.lex(str))
+ end
+
+ def match_list(tokens)
+ if m = @re.match(map_tokens(tokens))
+ then MatchData.new(tokens, m)
+ else nil
+ end
+ end
+
+ private
+
+ def compile(pattern)
+ if m = /[^\w\s$()\[\]{}?*+\.]/.match(pattern)
+ raise CompileError, "invalid char in pattern: #{m[0].inspect}"
+ end
+ buf = ''
+ pattern.scan(/(?:\w+|\$\(|[()\[\]\{\}?*+\.]+)/) do |tok|
+ case tok
+ when /\w/
+ buf.concat map_token(tok)
+ when '$('
+ buf.concat '('
+ when '('
+ buf.concat '(?:'
+ when /[?*\[\])\.]/
+ buf.concat tok
+ else
+ raise 'must not happen'
+ end
+ end
+ Regexp.compile(buf)
+ rescue RegexpError => err
+ raise CompileError, err.message
+ end
+
+ def map_tokens(tokens)
+ tokens.map {|pos,type,str| map_token(type.to_s.sub(/\Aon_/,'')) }.join
+ end
+
+ MAP = {}
+ seed = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+ SCANNER_EVENT_TABLE.each do |ev, |
+ raise CompileError, "[RIPPER FATAL] too many system token" if seed.empty?
+ MAP[ev.to_s.sub(/\Aon_/,'')] = seed.shift
+ end
+
+ def map_token(tok)
+ MAP[tok] or raise CompileError, "unknown token: #{tok}"
+ end
+
+ class MatchData
+ def initialize(tokens, match)
+ @tokens = tokens
+ @match = match
+ end
+
+ def string(n = 0)
+ return nil unless @match
+ match(n).join
+ end
+
+ private
+
+ def match(n = 0)
+ return [] unless @match
+ @tokens[@match.begin(n)...@match.end(n)].map {|pos,type,str| str }
+ end
+ end
+
+ end
+
+end
--- /dev/null
+#
+# $Id: sexp.rb 13465 2007-09-17 12:02:35Z aamine $
+#
+# Copyright (c) 2004,2005 Minero Aoki
+#
+# This program is free software.
+# You can distribute and/or modify this program under the Ruby License.
+# For details of Ruby License, see ruby/COPYING.
+#
+
+require 'ripper/core'
+
+class Ripper
+
+ # [EXPERIMENTAL]
+ # Parses +src+ and create S-exp tree.
+ # This method is for mainly developper use.
+ #
+ # require 'ripper'
+ # require 'pp
+ #
+ # pp Ripper.sexp("def m(a) nil end")
+ # #=> [:program,
+ # [:stmts_add,
+ # [:stmts_new],
+ # [:def,
+ # [:@ident, "m", [1, 4]],
+ # [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
+ # [:bodystmt,
+ # [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
+ # nil,
+ # nil,
+ # nil]]]]
+ #
+ def Ripper.sexp(src, filename = '-', lineno = 1)
+ SexpBuilderPP.new(src, filename, lineno).parse
+ end
+
+ def Ripper.sexp_raw(src, filename = '-', lineno = 1)
+ SexpBuilder.new(src, filename, lineno).parse
+ end
+
+ class SexpBuilderPP < ::Ripper #:nodoc:
+ private
+
+ PARSER_EVENT_TABLE.each do |event, arity|
+ if /_new\z/ =~ event.to_s and arity == 0
+ module_eval(<<-End, __FILE__, __LINE__ + 1)
+ def on_#{event}
+ []
+ end
+ End
+ elsif /_add\z/ =~ event.to_s
+ module_eval(<<-End, __FILE__, __LINE__ + 1)
+ def on_#{event}(list, item)
+ list.push item
+ list
+ end
+ End
+ else
+ module_eval(<<-End, __FILE__, __LINE__ + 1)
+ def on_#{event}(*args)
+ [:#{event}, *args]
+ end
+ End
+ end
+ end
+
+ SCANNER_EVENTS.each do |event|
+ module_eval(<<-End, __FILE__, __LINE__ + 1)
+ def on_#{event}(tok)
+ [:@#{event}, tok, [lineno(), column()]]
+ end
+ End
+ end
+ end
+
+ class SexpBuilder < ::Ripper #:nodoc:
+ private
+
+ PARSER_EVENTS.each do |event|
+ module_eval(<<-End, __FILE__, __LINE__ + 1)
+ def on_#{event}(*args)
+ args.unshift :#{event}
+ args
+ end
+ End
+ end
+
+ SCANNER_EVENTS.each do |event|
+ module_eval(<<-End, __FILE__, __LINE__ + 1)
+ def on_#{event}(tok)
+ [:@#{event}, tok, [lineno(), column()]]
+ end
+ End
+ end
+ end
+
+end
--- /dev/null
+#define PACKAGE_NAME ""
+#define PACKAGE_TARNAME ""
+#define PACKAGE_VERSION ""
+#define PACKAGE_STRING ""
+#define PACKAGE_BUGREPORT ""
+#define CANONICALIZATION_FOR_MATHN 1
+#define STDC_HEADERS 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STRING_H 1
+#define HAVE_MEMORY_H 1
+#define HAVE_STRINGS_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_UNISTD_H 1
+#define __EXTENSIONS__ 1
+#define _ALL_SOURCE 1
+#define _GNU_SOURCE 1
+#define _POSIX_PTHREAD_SEMANTICS 1
+#define _TANDEM_SOURCE 1
+#define HAVE_LONG_LONG 1
+#define HAVE_OFF_T 1
+#define SIZEOF_INT 4
+#define SIZEOF_SHORT 2
+#define SIZEOF_LONG 4
+#define SIZEOF_LONG_LONG 8
+#define SIZEOF___INT64 0
+#define SIZEOF_OFF_T 4
+#define SIZEOF_VOIDP 4
+#define SIZEOF_FLOAT 4
+#define SIZEOF_DOUBLE 8
+#define SIZEOF_TIME_T 4
+#define rb_pid_t pid_t
+#define PIDT2NUM(v) LONG2NUM(v)
+#define NUM2PIDT(v) NUM2LONG(v)
+#define rb_uid_t uid_t
+#define UIDT2NUM(v) ULONG2NUM(v)
+#define NUM2UIDT(v) NUM2ULONG(v)
+#define rb_gid_t gid_t
+#define GIDT2NUM(v) ULONG2NUM(v)
+#define NUM2GIDT(v) NUM2ULONG(v)
+#define HAVE_PROTOTYPES 1
+#define TOKEN_PASTE(x,y) x##y
+#define STRINGIZE(expr) STRINGIZE0(expr)
+#define HAVE_STDARG_PROTOTYPES 1
+#define HAVE_VA_ARGS_MACRO 1
+#define NORETURN(x) __attribute__ ((noreturn)) x
+#define DEPRECATED(x) __attribute__ ((deprecated)) x
+#define NOINLINE(x) __attribute__ ((noinline)) x
+#define FUNC_STDCALL(x) x
+#define FUNC_CDECL(x) x
+#define FUNC_FASTCALL(x) x
+#define RUBY_ALIAS_FUNCTION(old_prot, new_name, args) VALUE old_prot __attribute__((alias(#new_name)));
+#define HAVE_DECL_SYS_NERR 1
+#define HAVE_LIBDL 1
+#define HAVE_DIRENT_H 1
+#define HAVE_SYS_WAIT_H 1
+#define HAVE_LIMITS_H 1
+#define HAVE_SYS_FILE_H 1
+#define HAVE_SYS_IOCTL_H 1
+#define HAVE_SYS_SYSCALL_H 1
+#define HAVE_FCNTL_H 1
+#define HAVE_SYS_SELECT_H 1
+#define HAVE_SYS_TIME_H 1
+#define HAVE_SYS_TIMES_H 1
+#define HAVE_SYS_PARAM_H 1
+#define HAVE_PWD_H 1
+#define HAVE_GRP_H 1
+#define HAVE_A_OUT_H 1
+#define HAVE_UTIME_H 1
+#define HAVE_SYS_RESOURCE_H 1
+#define HAVE_SYS_UTIME_H 1
+#define HAVE_NETINET_IN_SYSTM_H 1
+#define HAVE_FLOAT_H 1
+#define HAVE_PTHREAD_H 1
+#define HAVE_LOCALE_H 1
+#define HAVE_SYS_SENDFILE_H 1
+#define HAVE_TIME_H 1
+#define HAVE_SYS_SOCKET_H 1
+#define SIZEOF_RLIM_T 0
+#define SIZEOF_SIZE_T 4
+#define SIZEOF_PTRDIFF_T 4
+#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
+#define HAVE_ST_BLKSIZE 1
+#define HAVE_STRUCT_STAT_ST_BLOCKS 1
+#define HAVE_ST_BLOCKS 1
+#define HAVE_STRUCT_STAT_ST_RDEV 1
+#define HAVE_ST_RDEV 1
+#define HAVE_STRUCT_TIMESPEC 1
+#define HAVE_INT8_T 1
+#define HAVE_UINT8_T 1
+#define HAVE_INT16_T 1
+#define HAVE_UINT16_T 1
+#define HAVE_INT32_T 1
+#define HAVE_UINT32_T 1
+#define HAVE_INT64_T 1
+#define HAVE_UINT64_T 1
+#define HAVE_INTPTR_T 1
+#define HAVE_UINTPTR_T 1
+#define HAVE_SSIZE_T 1
+#define GETGROUPS_T gid_t
+#define RETSIGTYPE void
+#define HAVE_ALLOCA_H 1
+#define HAVE_ALLOCA 1
+#define HAVE_MEMMOVE 1
+#define HAVE_STRERROR 1
+#define HAVE_STRCHR 1
+#define HAVE_STRSTR 1
+#define HAVE_VSNPRINTF 1
+#define HAVE_ISNAN 1
+#define HAVE_FINITE 1
+#define HAVE_ISINF 1
+#define HAVE_HYPOT 1
+#define HAVE_ACOSH 1
+#define HAVE_ERF 1
+#define HAVE_TGAMMA 1
+#define HAVE_LGAMMA_R 1
+#define HAVE_CBRT 1
+#define HAVE_STRLCPY 1
+#define HAVE_STRLCAT 1
+#define HAVE_FMOD 1
+#define HAVE_WAITPID 1
+#define HAVE_SYSCALL 1
+#define HAVE_TRUNCATE 1
+#define HAVE_TIMES 1
+#define HAVE_LSTAT 1
+#define HAVE_SOCKETPAIR 1
+#define HAVE_GETPRIORITY 1
+#define HAVE_GETRLIMIT 1
+#define HAVE_SETRLIMIT 1
+#define HAVE_DLOPEN 1
+#define HAVE_SIGPROCMASK 1
+#define HAVE_SIGACTION 1
+#define HAVE_SIGSETJMP 1
+#define HAVE__SETJMP 1
+#define HAVE__LONGJMP 1
+#define HAVE_COSH 1
+#define HAVE_SINH 1
+#define HAVE_TANH 1
+#define HAVE_ROUND 1
+#define HAVE_SETENV 1
+#define HAVE_UNSETENV 1
+#define HAVE_MKTIME 1
+#define HAVE_GMTIME_R 1
+#define HAVE_CLOCK_GETTIME 1
+#define HAVE_SENDFILE 1
+#define HAVE_SHUTDOWN 1
+#define RUBY_SETJMP(env) _setjmp(env)
+#define RUBY_LONGJMP(env,val) _longjmp(env,val)
+#define RUBY_JMP_BUF jmp_buf
+#define HAVE_STRUCT_TM_TM_ZONE 1
+#define HAVE_TM_ZONE 1
+#define HAVE_STRUCT_TM_TM_GMTOFF 1
+#define HAVE_VAR_TIMEZONE 1
+#define TYPEOF_VAR_TIMEZONE long
+#define NEGATIVE_TIME_T 1
+#define POSIX_SIGNAL 1
+#define GETPGRP_VOID 1
+#define SETPGRP_VOID 1
+#define RSHIFT(x,y) ((x)>>(int)y)
+#define FILE_COUNT _r
+#define FILE_READPTR _p
+#define HUGE_ST_INO 1
+#define STACK_GROW_DIRECTION 0
+#define _REENTRANT 1
+#define _THREAD_SAFE 1
+#define HAVE_LIBPTHREAD 1
+#define HAVE_NANOSLEEP 1
+#define HAVE_SCHED_YIELD 1
+#define USE_ELF 1
+#define DLEXT_MAXLEN 3
+#define DLEXT ".so"
+#define RUBY_LIB "/usr/local/lib/ruby/1.9.1"
+#define RUBY_SITE_LIB "/usr/local/lib/ruby/site_ruby"
+#define RUBY_SITE_LIB2 "/usr/local/lib/ruby/site_ruby/1.9.1"
+#define RUBY_VENDOR_LIB "/usr/local/lib/ruby/vendor_ruby"
+#define RUBY_VENDOR_LIB2 "/usr/local/lib/ruby/vendor_ruby/1.9.1"
+#define RUBY_PLATFORM "arm-linux"
+#define RUBY_ARCHLIB "/usr/local/lib/ruby/1.9.1/arm-linux"
+#define RUBY_SITE_ARCHLIB "/usr/local/lib/ruby/site_ruby/1.9.1/arm-linux"
+#define RUBY_VENDOR_ARCHLIB "/usr/local/lib/ruby/vendor_ruby/1.9.1/arm-linux"
--- /dev/null
+/************************************************
+
+ digest.h - header file for ruby digest modules
+
+ $Author: shyouhei $
+ created at: Fri May 25 08:54:56 JST 2001
+
+
+ Copyright (C) 2001-2006 Akinori MUSHA
+
+ $RoughId: digest.h,v 1.3 2001/07/13 15:38:27 knu Exp $
+ $Id: digest.h 11708 2007-02-12 23:01:19Z shyouhei $
+
+************************************************/
+
+#include "ruby.h"
+
+#define RUBY_DIGEST_API_VERSION 2
+
+typedef void (*rb_digest_hash_init_func_t)(void *);
+typedef void (*rb_digest_hash_update_func_t)(void *, unsigned char *, size_t);
+typedef void (*rb_digest_hash_finish_func_t)(void *, unsigned char *);
+
+typedef struct {
+ int api_version;
+ size_t digest_len;
+ size_t block_len;
+ size_t ctx_size;
+ rb_digest_hash_init_func_t init_func;
+ rb_digest_hash_update_func_t update_func;
+ rb_digest_hash_finish_func_t finish_func;
+} rb_digest_metadata_t;
--- /dev/null
+#ifndef RUBY_DL_H
+#define RUBY_DL_H
+
+#include <ruby.h>
+
+#if !defined(FUNC_CDECL)
+# define FUNC_CDECL(x) x
+#endif
+#if !defined(FUNC_STDCALL)
+# define FUNC_STDCALL(x) x
+#endif
+
+#if defined(HAVE_DLFCN_H)
+# include <dlfcn.h>
+# /* some stranger systems may not define all of these */
+#ifndef RTLD_LAZY
+#define RTLD_LAZY 0
+#endif
+#ifndef RTLD_GLOBAL
+#define RTLD_GLOBAL 0
+#endif
+#ifndef RTLD_NOW
+#define RTLD_NOW 0
+#endif
+#else
+# if defined(HAVE_WINDOWS_H)
+# include <windows.h>
+# define dlclose(ptr) FreeLibrary((HINSTANCE)ptr)
+# define dlopen(name,flag) ((void*)LoadLibrary(name))
+# define dlerror() "unknown error"
+# define dlsym(handle,name) ((void*)GetProcAddress(handle,name))
+# define RTLD_LAZY -1
+# define RTLD_NOW -1
+# define RTLD_GLOBAL -1
+# endif
+#endif
+
+#define MAX_CALLBACK 5
+#define DLSTACK_TYPE long
+#define DLSTACK_SIZE (20)
+#define DLSTACK_PROTO \
+ DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,\
+ DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,\
+ DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,\
+ DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE,DLSTACK_TYPE
+#define DLSTACK_ARGS(stack) \
+ stack[0],stack[1],stack[2],stack[3],stack[4],\
+ stack[5],stack[6],stack[7],stack[8],stack[9],\
+ stack[10],stack[11],stack[12],stack[13],stack[14],\
+ stack[15],stack[16],stack[17],stack[18],stack[19]
+
+#define DLSTACK_PROTO0
+#define DLSTACK_PROTO1_ DLSTACK_TYPE
+#define DLSTACK_PROTO2_ DLSTACK_PROTO1_, DLSTACK_TYPE
+#define DLSTACK_PROTO3_ DLSTACK_PROTO2_, DLSTACK_TYPE
+#define DLSTACK_PROTO4_ DLSTACK_PROTO3_, DLSTACK_TYPE
+#define DLSTACK_PROTO4_ DLSTACK_PROTO3_, DLSTACK_TYPE
+#define DLSTACK_PROTO5_ DLSTACK_PROTO4_, DLSTACK_TYPE
+#define DLSTACK_PROTO6_ DLSTACK_PROTO5_, DLSTACK_TYPE
+#define DLSTACK_PROTO7_ DLSTACK_PROTO6_, DLSTACK_TYPE
+#define DLSTACK_PROTO8_ DLSTACK_PROTO7_, DLSTACK_TYPE
+#define DLSTACK_PROTO9_ DLSTACK_PROTO8_, DLSTACK_TYPE
+#define DLSTACK_PROTO10_ DLSTACK_PROTO9_, DLSTACK_TYPE
+#define DLSTACK_PROTO11_ DLSTACK_PROTO10_, DLSTACK_TYPE
+#define DLSTACK_PROTO12_ DLSTACK_PROTO11_, DLSTACK_TYPE
+#define DLSTACK_PROTO13_ DLSTACK_PROTO12_, DLSTACK_TYPE
+#define DLSTACK_PROTO14_ DLSTACK_PROTO13_, DLSTACK_TYPE
+#define DLSTACK_PROTO14_ DLSTACK_PROTO13_, DLSTACK_TYPE
+#define DLSTACK_PROTO15_ DLSTACK_PROTO14_, DLSTACK_TYPE
+#define DLSTACK_PROTO16_ DLSTACK_PROTO15_, DLSTACK_TYPE
+#define DLSTACK_PROTO17_ DLSTACK_PROTO16_, DLSTACK_TYPE
+#define DLSTACK_PROTO18_ DLSTACK_PROTO17_, DLSTACK_TYPE
+#define DLSTACK_PROTO19_ DLSTACK_PROTO18_, DLSTACK_TYPE
+#define DLSTACK_PROTO20_ DLSTACK_PROTO19_, DLSTACK_TYPE
+
+/*
+ * Add ",..." as the last argument.
+ * This is required for variable argument functions such
+ * as fprintf() on x86_64-linux.
+ *
+ * http://refspecs.linuxfoundation.org/elf/x86_64-abi-0.95.pdf
+ * page 19:
+ *
+ * For calls that may call functions that use varargs or stdargs
+ * (prototype-less calls or calls to functions containing ellipsis
+ * (...) in the declaration) %al is used as hidden argument to
+ * specify the number of SSE registers used.
+ */
+#define DLSTACK_PROTO1 DLSTACK_PROTO1_, ...
+#define DLSTACK_PROTO2 DLSTACK_PROTO2_, ...
+#define DLSTACK_PROTO3 DLSTACK_PROTO3_, ...
+#define DLSTACK_PROTO4 DLSTACK_PROTO4_, ...
+#define DLSTACK_PROTO4 DLSTACK_PROTO4_, ...
+#define DLSTACK_PROTO5 DLSTACK_PROTO5_, ...
+#define DLSTACK_PROTO6 DLSTACK_PROTO6_, ...
+#define DLSTACK_PROTO7 DLSTACK_PROTO7_, ...
+#define DLSTACK_PROTO8 DLSTACK_PROTO8_, ...
+#define DLSTACK_PROTO9 DLSTACK_PROTO9_, ...
+#define DLSTACK_PROTO10 DLSTACK_PROTO10_, ...
+#define DLSTACK_PROTO11 DLSTACK_PROTO11_, ...
+#define DLSTACK_PROTO12 DLSTACK_PROTO12_, ...
+#define DLSTACK_PROTO13 DLSTACK_PROTO13_, ...
+#define DLSTACK_PROTO14 DLSTACK_PROTO14_, ...
+#define DLSTACK_PROTO14 DLSTACK_PROTO14_, ...
+#define DLSTACK_PROTO15 DLSTACK_PROTO15_, ...
+#define DLSTACK_PROTO16 DLSTACK_PROTO16_, ...
+#define DLSTACK_PROTO17 DLSTACK_PROTO17_, ...
+#define DLSTACK_PROTO18 DLSTACK_PROTO18_, ...
+#define DLSTACK_PROTO19 DLSTACK_PROTO19_, ...
+#define DLSTACK_PROTO20 DLSTACK_PROTO20_, ...
+
+#define DLSTACK_ARGS0(stack)
+#define DLSTACK_ARGS1(stack) stack[0]
+#define DLSTACK_ARGS2(stack) DLSTACK_ARGS1(stack), stack[1]
+#define DLSTACK_ARGS3(stack) DLSTACK_ARGS2(stack), stack[2]
+#define DLSTACK_ARGS4(stack) DLSTACK_ARGS3(stack), stack[3]
+#define DLSTACK_ARGS5(stack) DLSTACK_ARGS4(stack), stack[4]
+#define DLSTACK_ARGS6(stack) DLSTACK_ARGS5(stack), stack[5]
+#define DLSTACK_ARGS7(stack) DLSTACK_ARGS6(stack), stack[6]
+#define DLSTACK_ARGS8(stack) DLSTACK_ARGS7(stack), stack[7]
+#define DLSTACK_ARGS9(stack) DLSTACK_ARGS8(stack), stack[8]
+#define DLSTACK_ARGS10(stack) DLSTACK_ARGS9(stack), stack[9]
+#define DLSTACK_ARGS11(stack) DLSTACK_ARGS10(stack), stack[10]
+#define DLSTACK_ARGS12(stack) DLSTACK_ARGS11(stack), stack[11]
+#define DLSTACK_ARGS13(stack) DLSTACK_ARGS12(stack), stack[12]
+#define DLSTACK_ARGS14(stack) DLSTACK_ARGS13(stack), stack[13]
+#define DLSTACK_ARGS15(stack) DLSTACK_ARGS14(stack), stack[14]
+#define DLSTACK_ARGS16(stack) DLSTACK_ARGS15(stack), stack[15]
+#define DLSTACK_ARGS17(stack) DLSTACK_ARGS16(stack), stack[16]
+#define DLSTACK_ARGS18(stack) DLSTACK_ARGS17(stack), stack[17]
+#define DLSTACK_ARGS19(stack) DLSTACK_ARGS18(stack), stack[18]
+#define DLSTACK_ARGS20(stack) DLSTACK_ARGS19(stack), stack[19]
+
+extern VALUE rb_mDL;
+extern VALUE rb_cDLHandle;
+extern VALUE rb_cDLSymbol;
+extern VALUE rb_eDLError;
+extern VALUE rb_eDLTypeError;
+
+typedef struct { char c; void *x; } s_voidp;
+typedef struct { char c; short x; } s_short;
+typedef struct { char c; int x; } s_int;
+typedef struct { char c; long x; } s_long;
+typedef struct { char c; float x; } s_float;
+typedef struct { char c; double x; } s_double;
+#if HAVE_LONG_LONG
+typedef struct { char c; LONG_LONG x; } s_long_long;
+#endif
+
+#define ALIGN_VOIDP (sizeof(s_voidp) - sizeof(void *))
+#define ALIGN_SHORT (sizeof(s_short) - sizeof(short))
+#define ALIGN_CHAR (1)
+#define ALIGN_INT (sizeof(s_int) - sizeof(int))
+#define ALIGN_LONG (sizeof(s_long) - sizeof(long))
+#if HAVE_LONG_LONG
+#define ALIGN_LONG_LONG (sizeof(s_long_long) - sizeof(LONG_LONG))
+#endif
+#define ALIGN_FLOAT (sizeof(s_float) - sizeof(float))
+#define ALIGN_DOUBLE (sizeof(s_double) - sizeof(double))
+
+#define DLALIGN(ptr,offset,align) {\
+ while( (((unsigned long)((char *)ptr + offset)) % align) != 0 ) offset++;\
+}
+
+
+#define DLTYPE_VOID 0
+#define DLTYPE_VOIDP 1
+#define DLTYPE_CHAR 2
+#define DLTYPE_SHORT 3
+#define DLTYPE_INT 4
+#define DLTYPE_LONG 5
+#if HAVE_LONG_LONG
+#define DLTYPE_LONG_LONG 6
+#endif
+#define DLTYPE_FLOAT 7
+#define DLTYPE_DOUBLE 8
+#define MAX_DLTYPE 9
+
+#if SIZEOF_VOIDP == SIZEOF_LONG
+# define PTR2NUM(x) (ULONG2NUM((unsigned long)(x)))
+# define NUM2PTR(x) ((void*)(NUM2ULONG(x)))
+#else
+/* # error --->> Ruby/DL2 requires sizeof(void*) == sizeof(long) to be compiled. <<--- */
+# define PTR2NUM(x) (ULL2NUM((unsigned long long)(x)))
+# define NUM2PTR(x) ((void*)(NUM2ULL(x)))
+#endif
+
+#define BOOL2INT(x) ((x == Qtrue)?1:0)
+#define INT2BOOL(x) (x?Qtrue:Qfalse)
+
+typedef void (*freefunc_t)(void*);
+
+struct dl_handle {
+ void *ptr;
+ int open;
+ int enable_close;
+};
+
+
+struct cfunc_data {
+ void *ptr;
+ char *name;
+ int type;
+ ID calltype;
+};
+extern ID rbdl_id_cdecl;
+extern ID rbdl_id_stdcall;
+#define CFUNC_CDECL (rbdl_id_cdecl)
+#define CFUNC_STDCALL (rbdl_id_stdcall)
+
+struct ptr_data {
+ void *ptr;
+ long size;
+ freefunc_t free;
+};
+
+#define RDL_HANDLE(obj) ((struct dl_handle *)(DATA_PTR(obj)))
+#define RCFUNC_DATA(obj) ((struct cfunc_data *)(DATA_PTR(obj)))
+#define RPTR_DATA(obj) ((struct ptr_data *)(DATA_PTR(obj)))
+
+VALUE rb_dlcfunc_new(void (*func)(), int dltype, const char * name, ID calltype);
+VALUE rb_dlptr_new(void *ptr, long size, freefunc_t func);
+VALUE rb_dlptr_new2(VALUE klass, void *ptr, long size, freefunc_t func);
+VALUE rb_dlptr_malloc(long size, freefunc_t func);
+
+#endif
if RUBY_PLATFORM =~ /mswin|bccwin|mingw/; \
class File; \
remove_const :ALT_SEPARATOR; \
- ALT_SEPARATOR = "\\"; \
+ ALT_SEPARATOR = "\\\\"; \
end; \
end; \
' > $@
VCS = svn
-all: encs exts
+all: exts
exts: $(MKFILES) incs $(PREP) $(RBCONFIG) $(LIBRUBY)
@$(MINIRUBY) $(srcdir)/ext/extmk.rb --make="$(MAKE)" $(EXTMK_ARGS)
prog: $(PROGRAM) $(WPROGRAM)
--- /dev/null
+#!/bin/sh
+TOP=${HOME}/android
+PRODUCT=dream
+HOST=linux-x86
+GCCHOST=i686-linux
+ARCH=arch-arm
+GCCARCH=arm-eabi
+GCCVER=4.2.1
+RUBYARCH=arm-android-linux
+TOOLCHAIN_PATH=${TOP}/prebuilt/${HOST}/toolchain/${GCCARCH}-${GCCVER}
+TOOLCHAIN_PREFIX=${TOOLCHAIN_PATH}/bin/${GCCARCH}-
+LPATH=${TOP}/out/target/product/${PRODUCT}/obj/lib
+
+export CC=${TOOLCHAIN_PREFIX}gcc
+export LD=${TOOLCHAIN_PREFIX}ld
+export AR=${TOOLCHAIN_PREFIX}ar
+export RANLIB=${TOOLCHAIN_PREFIX}ranlib
+export CPPFLAGS="-nostdinc -I${TOP}/external/zlib -I${TOP}/external/openssl/include -I${TOP}/bionic/libc/include -I${TOP}/bionic/libc/${ARCH}/include -I${TOP}/bionic/libc/kernel/common -I${TOP}/bionic/libc/kernel/${ARCH} -I${TOP}/bionic/libc/kernel/common/linux -I${TOP}/bionic/libm/include -I${TOOLCHAIN_PATH}/lib/gcc/${GCCARCH}/${GCCVER}/include -Dptrdiff_t=__ptrdiff_t -include stdio.h -include unistd.h -include fcntl.h -include sys/mman.h -DHAVE_GETCWD"
+export LIBS="-nostdlib -L${LPATH} ${LPATH}/crtbegin_dynamic.o -lstdc++ -lc -lm -ldl ${LPATH}/crtend_android.o -Wl,-dynamic-linker,/system/bin/linker,-rpath,/system/lib"
+
+export ac_cv_func_getpgrp_void=yes
+export ac_cv_func_setpgrp_void=yes
+export ac_cv_prog_cc_g=no
+export ac_cv_prog_cxx_g=no
+export ac_cv_func_vsnprintf=yes
+export ac_cv_func_isinf=yes
+export ac_cv_header_langinfo_h=no
+
+./configure --build=${RUBYARCH} --target=${RUBYARCH} --host=${GCCHOST} --with-static-linked-ext --enable-wide-getaddrinfo
if test "$rb_cv_binary_elf" = no; then
with_dln_a_out=yes
else
- LDFLAGS="$LDFLAGS -rdynamic"
+ case "$target_vendor" in
+ android) ;;
+ *) LDFLAGS="$LDFLAGS -rdynamic" ;;
+ esac
fi;;
esac
LIBEXT=a
-#option nodynamic
+option nodynamic
#Win32API
#bigdecimal
#readline
#ripper
#sdbm
-#socket
+socket
#stringio
#strscan
#syck
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_CDECL(rb_dl_callback_void_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 0), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+
+static void
+FUNC_STDCALL(rb_dl_callback_void_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 0), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return ;
+}
+
+void
+rb_dl_init_callbacks_0()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_void_0_0_cdecl),PTR2NUM(rb_dl_callback_void_1_0_cdecl),PTR2NUM(rb_dl_callback_void_2_0_cdecl),PTR2NUM(rb_dl_callback_void_3_0_cdecl),PTR2NUM(rb_dl_callback_void_4_0_cdecl),PTR2NUM(rb_dl_callback_void_5_0_cdecl),PTR2NUM(rb_dl_callback_void_6_0_cdecl),PTR2NUM(rb_dl_callback_void_7_0_cdecl),PTR2NUM(rb_dl_callback_void_8_0_cdecl),PTR2NUM(rb_dl_callback_void_9_0_cdecl),PTR2NUM(rb_dl_callback_void_10_0_cdecl),PTR2NUM(rb_dl_callback_void_11_0_cdecl),PTR2NUM(rb_dl_callback_void_12_0_cdecl),PTR2NUM(rb_dl_callback_void_13_0_cdecl),PTR2NUM(rb_dl_callback_void_14_0_cdecl),PTR2NUM(rb_dl_callback_void_15_0_cdecl),PTR2NUM(rb_dl_callback_void_16_0_cdecl),PTR2NUM(rb_dl_callback_void_17_0_cdecl),PTR2NUM(rb_dl_callback_void_18_0_cdecl),PTR2NUM(rb_dl_callback_void_19_0_cdecl),PTR2NUM(rb_dl_callback_void_0_1_cdecl),PTR2NUM(rb_dl_callback_void_1_1_cdecl),PTR2NUM(rb_dl_callback_void_2_1_cdecl),PTR2NUM(rb_dl_callback_void_3_1_cdecl),PTR2NUM(rb_dl_callback_void_4_1_cdecl),PTR2NUM(rb_dl_callback_void_5_1_cdecl),PTR2NUM(rb_dl_callback_void_6_1_cdecl),PTR2NUM(rb_dl_callback_void_7_1_cdecl),PTR2NUM(rb_dl_callback_void_8_1_cdecl),PTR2NUM(rb_dl_callback_void_9_1_cdecl),PTR2NUM(rb_dl_callback_void_10_1_cdecl),PTR2NUM(rb_dl_callback_void_11_1_cdecl),PTR2NUM(rb_dl_callback_void_12_1_cdecl),PTR2NUM(rb_dl_callback_void_13_1_cdecl),PTR2NUM(rb_dl_callback_void_14_1_cdecl),PTR2NUM(rb_dl_callback_void_15_1_cdecl),PTR2NUM(rb_dl_callback_void_16_1_cdecl),PTR2NUM(rb_dl_callback_void_17_1_cdecl),PTR2NUM(rb_dl_callback_void_18_1_cdecl),PTR2NUM(rb_dl_callback_void_19_1_cdecl),PTR2NUM(rb_dl_callback_void_0_2_cdecl),PTR2NUM(rb_dl_callback_void_1_2_cdecl),PTR2NUM(rb_dl_callback_void_2_2_cdecl),PTR2NUM(rb_dl_callback_void_3_2_cdecl),PTR2NUM(rb_dl_callback_void_4_2_cdecl),PTR2NUM(rb_dl_callback_void_5_2_cdecl),PTR2NUM(rb_dl_callback_void_6_2_cdecl),PTR2NUM(rb_dl_callback_void_7_2_cdecl),PTR2NUM(rb_dl_callback_void_8_2_cdecl),PTR2NUM(rb_dl_callback_void_9_2_cdecl),PTR2NUM(rb_dl_callback_void_10_2_cdecl),PTR2NUM(rb_dl_callback_void_11_2_cdecl),PTR2NUM(rb_dl_callback_void_12_2_cdecl),PTR2NUM(rb_dl_callback_void_13_2_cdecl),PTR2NUM(rb_dl_callback_void_14_2_cdecl),PTR2NUM(rb_dl_callback_void_15_2_cdecl),PTR2NUM(rb_dl_callback_void_16_2_cdecl),PTR2NUM(rb_dl_callback_void_17_2_cdecl),PTR2NUM(rb_dl_callback_void_18_2_cdecl),PTR2NUM(rb_dl_callback_void_19_2_cdecl),PTR2NUM(rb_dl_callback_void_0_3_cdecl),PTR2NUM(rb_dl_callback_void_1_3_cdecl),PTR2NUM(rb_dl_callback_void_2_3_cdecl),PTR2NUM(rb_dl_callback_void_3_3_cdecl),PTR2NUM(rb_dl_callback_void_4_3_cdecl),PTR2NUM(rb_dl_callback_void_5_3_cdecl),PTR2NUM(rb_dl_callback_void_6_3_cdecl),PTR2NUM(rb_dl_callback_void_7_3_cdecl),PTR2NUM(rb_dl_callback_void_8_3_cdecl),PTR2NUM(rb_dl_callback_void_9_3_cdecl),PTR2NUM(rb_dl_callback_void_10_3_cdecl),PTR2NUM(rb_dl_callback_void_11_3_cdecl),PTR2NUM(rb_dl_callback_void_12_3_cdecl),PTR2NUM(rb_dl_callback_void_13_3_cdecl),PTR2NUM(rb_dl_callback_void_14_3_cdecl),PTR2NUM(rb_dl_callback_void_15_3_cdecl),PTR2NUM(rb_dl_callback_void_16_3_cdecl),PTR2NUM(rb_dl_callback_void_17_3_cdecl),PTR2NUM(rb_dl_callback_void_18_3_cdecl),PTR2NUM(rb_dl_callback_void_19_3_cdecl),PTR2NUM(rb_dl_callback_void_0_4_cdecl),PTR2NUM(rb_dl_callback_void_1_4_cdecl),PTR2NUM(rb_dl_callback_void_2_4_cdecl),PTR2NUM(rb_dl_callback_void_3_4_cdecl),PTR2NUM(rb_dl_callback_void_4_4_cdecl),PTR2NUM(rb_dl_callback_void_5_4_cdecl),PTR2NUM(rb_dl_callback_void_6_4_cdecl),PTR2NUM(rb_dl_callback_void_7_4_cdecl),PTR2NUM(rb_dl_callback_void_8_4_cdecl),PTR2NUM(rb_dl_callback_void_9_4_cdecl),PTR2NUM(rb_dl_callback_void_10_4_cdecl),PTR2NUM(rb_dl_callback_void_11_4_cdecl),PTR2NUM(rb_dl_callback_void_12_4_cdecl),PTR2NUM(rb_dl_callback_void_13_4_cdecl),PTR2NUM(rb_dl_callback_void_14_4_cdecl),PTR2NUM(rb_dl_callback_void_15_4_cdecl),PTR2NUM(rb_dl_callback_void_16_4_cdecl),PTR2NUM(rb_dl_callback_void_17_4_cdecl),PTR2NUM(rb_dl_callback_void_18_4_cdecl),PTR2NUM(rb_dl_callback_void_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_void_0_0_stdcall),PTR2NUM(rb_dl_callback_void_1_0_stdcall),PTR2NUM(rb_dl_callback_void_2_0_stdcall),PTR2NUM(rb_dl_callback_void_3_0_stdcall),PTR2NUM(rb_dl_callback_void_4_0_stdcall),PTR2NUM(rb_dl_callback_void_5_0_stdcall),PTR2NUM(rb_dl_callback_void_6_0_stdcall),PTR2NUM(rb_dl_callback_void_7_0_stdcall),PTR2NUM(rb_dl_callback_void_8_0_stdcall),PTR2NUM(rb_dl_callback_void_9_0_stdcall),PTR2NUM(rb_dl_callback_void_10_0_stdcall),PTR2NUM(rb_dl_callback_void_11_0_stdcall),PTR2NUM(rb_dl_callback_void_12_0_stdcall),PTR2NUM(rb_dl_callback_void_13_0_stdcall),PTR2NUM(rb_dl_callback_void_14_0_stdcall),PTR2NUM(rb_dl_callback_void_15_0_stdcall),PTR2NUM(rb_dl_callback_void_16_0_stdcall),PTR2NUM(rb_dl_callback_void_17_0_stdcall),PTR2NUM(rb_dl_callback_void_18_0_stdcall),PTR2NUM(rb_dl_callback_void_19_0_stdcall),PTR2NUM(rb_dl_callback_void_0_1_stdcall),PTR2NUM(rb_dl_callback_void_1_1_stdcall),PTR2NUM(rb_dl_callback_void_2_1_stdcall),PTR2NUM(rb_dl_callback_void_3_1_stdcall),PTR2NUM(rb_dl_callback_void_4_1_stdcall),PTR2NUM(rb_dl_callback_void_5_1_stdcall),PTR2NUM(rb_dl_callback_void_6_1_stdcall),PTR2NUM(rb_dl_callback_void_7_1_stdcall),PTR2NUM(rb_dl_callback_void_8_1_stdcall),PTR2NUM(rb_dl_callback_void_9_1_stdcall),PTR2NUM(rb_dl_callback_void_10_1_stdcall),PTR2NUM(rb_dl_callback_void_11_1_stdcall),PTR2NUM(rb_dl_callback_void_12_1_stdcall),PTR2NUM(rb_dl_callback_void_13_1_stdcall),PTR2NUM(rb_dl_callback_void_14_1_stdcall),PTR2NUM(rb_dl_callback_void_15_1_stdcall),PTR2NUM(rb_dl_callback_void_16_1_stdcall),PTR2NUM(rb_dl_callback_void_17_1_stdcall),PTR2NUM(rb_dl_callback_void_18_1_stdcall),PTR2NUM(rb_dl_callback_void_19_1_stdcall),PTR2NUM(rb_dl_callback_void_0_2_stdcall),PTR2NUM(rb_dl_callback_void_1_2_stdcall),PTR2NUM(rb_dl_callback_void_2_2_stdcall),PTR2NUM(rb_dl_callback_void_3_2_stdcall),PTR2NUM(rb_dl_callback_void_4_2_stdcall),PTR2NUM(rb_dl_callback_void_5_2_stdcall),PTR2NUM(rb_dl_callback_void_6_2_stdcall),PTR2NUM(rb_dl_callback_void_7_2_stdcall),PTR2NUM(rb_dl_callback_void_8_2_stdcall),PTR2NUM(rb_dl_callback_void_9_2_stdcall),PTR2NUM(rb_dl_callback_void_10_2_stdcall),PTR2NUM(rb_dl_callback_void_11_2_stdcall),PTR2NUM(rb_dl_callback_void_12_2_stdcall),PTR2NUM(rb_dl_callback_void_13_2_stdcall),PTR2NUM(rb_dl_callback_void_14_2_stdcall),PTR2NUM(rb_dl_callback_void_15_2_stdcall),PTR2NUM(rb_dl_callback_void_16_2_stdcall),PTR2NUM(rb_dl_callback_void_17_2_stdcall),PTR2NUM(rb_dl_callback_void_18_2_stdcall),PTR2NUM(rb_dl_callback_void_19_2_stdcall),PTR2NUM(rb_dl_callback_void_0_3_stdcall),PTR2NUM(rb_dl_callback_void_1_3_stdcall),PTR2NUM(rb_dl_callback_void_2_3_stdcall),PTR2NUM(rb_dl_callback_void_3_3_stdcall),PTR2NUM(rb_dl_callback_void_4_3_stdcall),PTR2NUM(rb_dl_callback_void_5_3_stdcall),PTR2NUM(rb_dl_callback_void_6_3_stdcall),PTR2NUM(rb_dl_callback_void_7_3_stdcall),PTR2NUM(rb_dl_callback_void_8_3_stdcall),PTR2NUM(rb_dl_callback_void_9_3_stdcall),PTR2NUM(rb_dl_callback_void_10_3_stdcall),PTR2NUM(rb_dl_callback_void_11_3_stdcall),PTR2NUM(rb_dl_callback_void_12_3_stdcall),PTR2NUM(rb_dl_callback_void_13_3_stdcall),PTR2NUM(rb_dl_callback_void_14_3_stdcall),PTR2NUM(rb_dl_callback_void_15_3_stdcall),PTR2NUM(rb_dl_callback_void_16_3_stdcall),PTR2NUM(rb_dl_callback_void_17_3_stdcall),PTR2NUM(rb_dl_callback_void_18_3_stdcall),PTR2NUM(rb_dl_callback_void_19_3_stdcall),PTR2NUM(rb_dl_callback_void_0_4_stdcall),PTR2NUM(rb_dl_callback_void_1_4_stdcall),PTR2NUM(rb_dl_callback_void_2_4_stdcall),PTR2NUM(rb_dl_callback_void_3_4_stdcall),PTR2NUM(rb_dl_callback_void_4_4_stdcall),PTR2NUM(rb_dl_callback_void_5_4_stdcall),PTR2NUM(rb_dl_callback_void_6_4_stdcall),PTR2NUM(rb_dl_callback_void_7_4_stdcall),PTR2NUM(rb_dl_callback_void_8_4_stdcall),PTR2NUM(rb_dl_callback_void_9_4_stdcall),PTR2NUM(rb_dl_callback_void_10_4_stdcall),PTR2NUM(rb_dl_callback_void_11_4_stdcall),PTR2NUM(rb_dl_callback_void_12_4_stdcall),PTR2NUM(rb_dl_callback_void_13_4_stdcall),PTR2NUM(rb_dl_callback_void_14_4_stdcall),PTR2NUM(rb_dl_callback_void_15_4_stdcall),PTR2NUM(rb_dl_callback_void_16_4_stdcall),PTR2NUM(rb_dl_callback_void_17_4_stdcall),PTR2NUM(rb_dl_callback_void_18_4_stdcall),PTR2NUM(rb_dl_callback_void_19_4_stdcall)));
+}
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_CDECL(rb_dl_callback_ptr_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 1), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+
+static void *
+FUNC_STDCALL(rb_dl_callback_ptr_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 1), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2PTR(ret);
+}
+
+void
+rb_dl_init_callbacks_1()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_ptr_0_0_cdecl),PTR2NUM(rb_dl_callback_ptr_1_0_cdecl),PTR2NUM(rb_dl_callback_ptr_2_0_cdecl),PTR2NUM(rb_dl_callback_ptr_3_0_cdecl),PTR2NUM(rb_dl_callback_ptr_4_0_cdecl),PTR2NUM(rb_dl_callback_ptr_5_0_cdecl),PTR2NUM(rb_dl_callback_ptr_6_0_cdecl),PTR2NUM(rb_dl_callback_ptr_7_0_cdecl),PTR2NUM(rb_dl_callback_ptr_8_0_cdecl),PTR2NUM(rb_dl_callback_ptr_9_0_cdecl),PTR2NUM(rb_dl_callback_ptr_10_0_cdecl),PTR2NUM(rb_dl_callback_ptr_11_0_cdecl),PTR2NUM(rb_dl_callback_ptr_12_0_cdecl),PTR2NUM(rb_dl_callback_ptr_13_0_cdecl),PTR2NUM(rb_dl_callback_ptr_14_0_cdecl),PTR2NUM(rb_dl_callback_ptr_15_0_cdecl),PTR2NUM(rb_dl_callback_ptr_16_0_cdecl),PTR2NUM(rb_dl_callback_ptr_17_0_cdecl),PTR2NUM(rb_dl_callback_ptr_18_0_cdecl),PTR2NUM(rb_dl_callback_ptr_19_0_cdecl),PTR2NUM(rb_dl_callback_ptr_0_1_cdecl),PTR2NUM(rb_dl_callback_ptr_1_1_cdecl),PTR2NUM(rb_dl_callback_ptr_2_1_cdecl),PTR2NUM(rb_dl_callback_ptr_3_1_cdecl),PTR2NUM(rb_dl_callback_ptr_4_1_cdecl),PTR2NUM(rb_dl_callback_ptr_5_1_cdecl),PTR2NUM(rb_dl_callback_ptr_6_1_cdecl),PTR2NUM(rb_dl_callback_ptr_7_1_cdecl),PTR2NUM(rb_dl_callback_ptr_8_1_cdecl),PTR2NUM(rb_dl_callback_ptr_9_1_cdecl),PTR2NUM(rb_dl_callback_ptr_10_1_cdecl),PTR2NUM(rb_dl_callback_ptr_11_1_cdecl),PTR2NUM(rb_dl_callback_ptr_12_1_cdecl),PTR2NUM(rb_dl_callback_ptr_13_1_cdecl),PTR2NUM(rb_dl_callback_ptr_14_1_cdecl),PTR2NUM(rb_dl_callback_ptr_15_1_cdecl),PTR2NUM(rb_dl_callback_ptr_16_1_cdecl),PTR2NUM(rb_dl_callback_ptr_17_1_cdecl),PTR2NUM(rb_dl_callback_ptr_18_1_cdecl),PTR2NUM(rb_dl_callback_ptr_19_1_cdecl),PTR2NUM(rb_dl_callback_ptr_0_2_cdecl),PTR2NUM(rb_dl_callback_ptr_1_2_cdecl),PTR2NUM(rb_dl_callback_ptr_2_2_cdecl),PTR2NUM(rb_dl_callback_ptr_3_2_cdecl),PTR2NUM(rb_dl_callback_ptr_4_2_cdecl),PTR2NUM(rb_dl_callback_ptr_5_2_cdecl),PTR2NUM(rb_dl_callback_ptr_6_2_cdecl),PTR2NUM(rb_dl_callback_ptr_7_2_cdecl),PTR2NUM(rb_dl_callback_ptr_8_2_cdecl),PTR2NUM(rb_dl_callback_ptr_9_2_cdecl),PTR2NUM(rb_dl_callback_ptr_10_2_cdecl),PTR2NUM(rb_dl_callback_ptr_11_2_cdecl),PTR2NUM(rb_dl_callback_ptr_12_2_cdecl),PTR2NUM(rb_dl_callback_ptr_13_2_cdecl),PTR2NUM(rb_dl_callback_ptr_14_2_cdecl),PTR2NUM(rb_dl_callback_ptr_15_2_cdecl),PTR2NUM(rb_dl_callback_ptr_16_2_cdecl),PTR2NUM(rb_dl_callback_ptr_17_2_cdecl),PTR2NUM(rb_dl_callback_ptr_18_2_cdecl),PTR2NUM(rb_dl_callback_ptr_19_2_cdecl),PTR2NUM(rb_dl_callback_ptr_0_3_cdecl),PTR2NUM(rb_dl_callback_ptr_1_3_cdecl),PTR2NUM(rb_dl_callback_ptr_2_3_cdecl),PTR2NUM(rb_dl_callback_ptr_3_3_cdecl),PTR2NUM(rb_dl_callback_ptr_4_3_cdecl),PTR2NUM(rb_dl_callback_ptr_5_3_cdecl),PTR2NUM(rb_dl_callback_ptr_6_3_cdecl),PTR2NUM(rb_dl_callback_ptr_7_3_cdecl),PTR2NUM(rb_dl_callback_ptr_8_3_cdecl),PTR2NUM(rb_dl_callback_ptr_9_3_cdecl),PTR2NUM(rb_dl_callback_ptr_10_3_cdecl),PTR2NUM(rb_dl_callback_ptr_11_3_cdecl),PTR2NUM(rb_dl_callback_ptr_12_3_cdecl),PTR2NUM(rb_dl_callback_ptr_13_3_cdecl),PTR2NUM(rb_dl_callback_ptr_14_3_cdecl),PTR2NUM(rb_dl_callback_ptr_15_3_cdecl),PTR2NUM(rb_dl_callback_ptr_16_3_cdecl),PTR2NUM(rb_dl_callback_ptr_17_3_cdecl),PTR2NUM(rb_dl_callback_ptr_18_3_cdecl),PTR2NUM(rb_dl_callback_ptr_19_3_cdecl),PTR2NUM(rb_dl_callback_ptr_0_4_cdecl),PTR2NUM(rb_dl_callback_ptr_1_4_cdecl),PTR2NUM(rb_dl_callback_ptr_2_4_cdecl),PTR2NUM(rb_dl_callback_ptr_3_4_cdecl),PTR2NUM(rb_dl_callback_ptr_4_4_cdecl),PTR2NUM(rb_dl_callback_ptr_5_4_cdecl),PTR2NUM(rb_dl_callback_ptr_6_4_cdecl),PTR2NUM(rb_dl_callback_ptr_7_4_cdecl),PTR2NUM(rb_dl_callback_ptr_8_4_cdecl),PTR2NUM(rb_dl_callback_ptr_9_4_cdecl),PTR2NUM(rb_dl_callback_ptr_10_4_cdecl),PTR2NUM(rb_dl_callback_ptr_11_4_cdecl),PTR2NUM(rb_dl_callback_ptr_12_4_cdecl),PTR2NUM(rb_dl_callback_ptr_13_4_cdecl),PTR2NUM(rb_dl_callback_ptr_14_4_cdecl),PTR2NUM(rb_dl_callback_ptr_15_4_cdecl),PTR2NUM(rb_dl_callback_ptr_16_4_cdecl),PTR2NUM(rb_dl_callback_ptr_17_4_cdecl),PTR2NUM(rb_dl_callback_ptr_18_4_cdecl),PTR2NUM(rb_dl_callback_ptr_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_ptr_0_0_stdcall),PTR2NUM(rb_dl_callback_ptr_1_0_stdcall),PTR2NUM(rb_dl_callback_ptr_2_0_stdcall),PTR2NUM(rb_dl_callback_ptr_3_0_stdcall),PTR2NUM(rb_dl_callback_ptr_4_0_stdcall),PTR2NUM(rb_dl_callback_ptr_5_0_stdcall),PTR2NUM(rb_dl_callback_ptr_6_0_stdcall),PTR2NUM(rb_dl_callback_ptr_7_0_stdcall),PTR2NUM(rb_dl_callback_ptr_8_0_stdcall),PTR2NUM(rb_dl_callback_ptr_9_0_stdcall),PTR2NUM(rb_dl_callback_ptr_10_0_stdcall),PTR2NUM(rb_dl_callback_ptr_11_0_stdcall),PTR2NUM(rb_dl_callback_ptr_12_0_stdcall),PTR2NUM(rb_dl_callback_ptr_13_0_stdcall),PTR2NUM(rb_dl_callback_ptr_14_0_stdcall),PTR2NUM(rb_dl_callback_ptr_15_0_stdcall),PTR2NUM(rb_dl_callback_ptr_16_0_stdcall),PTR2NUM(rb_dl_callback_ptr_17_0_stdcall),PTR2NUM(rb_dl_callback_ptr_18_0_stdcall),PTR2NUM(rb_dl_callback_ptr_19_0_stdcall),PTR2NUM(rb_dl_callback_ptr_0_1_stdcall),PTR2NUM(rb_dl_callback_ptr_1_1_stdcall),PTR2NUM(rb_dl_callback_ptr_2_1_stdcall),PTR2NUM(rb_dl_callback_ptr_3_1_stdcall),PTR2NUM(rb_dl_callback_ptr_4_1_stdcall),PTR2NUM(rb_dl_callback_ptr_5_1_stdcall),PTR2NUM(rb_dl_callback_ptr_6_1_stdcall),PTR2NUM(rb_dl_callback_ptr_7_1_stdcall),PTR2NUM(rb_dl_callback_ptr_8_1_stdcall),PTR2NUM(rb_dl_callback_ptr_9_1_stdcall),PTR2NUM(rb_dl_callback_ptr_10_1_stdcall),PTR2NUM(rb_dl_callback_ptr_11_1_stdcall),PTR2NUM(rb_dl_callback_ptr_12_1_stdcall),PTR2NUM(rb_dl_callback_ptr_13_1_stdcall),PTR2NUM(rb_dl_callback_ptr_14_1_stdcall),PTR2NUM(rb_dl_callback_ptr_15_1_stdcall),PTR2NUM(rb_dl_callback_ptr_16_1_stdcall),PTR2NUM(rb_dl_callback_ptr_17_1_stdcall),PTR2NUM(rb_dl_callback_ptr_18_1_stdcall),PTR2NUM(rb_dl_callback_ptr_19_1_stdcall),PTR2NUM(rb_dl_callback_ptr_0_2_stdcall),PTR2NUM(rb_dl_callback_ptr_1_2_stdcall),PTR2NUM(rb_dl_callback_ptr_2_2_stdcall),PTR2NUM(rb_dl_callback_ptr_3_2_stdcall),PTR2NUM(rb_dl_callback_ptr_4_2_stdcall),PTR2NUM(rb_dl_callback_ptr_5_2_stdcall),PTR2NUM(rb_dl_callback_ptr_6_2_stdcall),PTR2NUM(rb_dl_callback_ptr_7_2_stdcall),PTR2NUM(rb_dl_callback_ptr_8_2_stdcall),PTR2NUM(rb_dl_callback_ptr_9_2_stdcall),PTR2NUM(rb_dl_callback_ptr_10_2_stdcall),PTR2NUM(rb_dl_callback_ptr_11_2_stdcall),PTR2NUM(rb_dl_callback_ptr_12_2_stdcall),PTR2NUM(rb_dl_callback_ptr_13_2_stdcall),PTR2NUM(rb_dl_callback_ptr_14_2_stdcall),PTR2NUM(rb_dl_callback_ptr_15_2_stdcall),PTR2NUM(rb_dl_callback_ptr_16_2_stdcall),PTR2NUM(rb_dl_callback_ptr_17_2_stdcall),PTR2NUM(rb_dl_callback_ptr_18_2_stdcall),PTR2NUM(rb_dl_callback_ptr_19_2_stdcall),PTR2NUM(rb_dl_callback_ptr_0_3_stdcall),PTR2NUM(rb_dl_callback_ptr_1_3_stdcall),PTR2NUM(rb_dl_callback_ptr_2_3_stdcall),PTR2NUM(rb_dl_callback_ptr_3_3_stdcall),PTR2NUM(rb_dl_callback_ptr_4_3_stdcall),PTR2NUM(rb_dl_callback_ptr_5_3_stdcall),PTR2NUM(rb_dl_callback_ptr_6_3_stdcall),PTR2NUM(rb_dl_callback_ptr_7_3_stdcall),PTR2NUM(rb_dl_callback_ptr_8_3_stdcall),PTR2NUM(rb_dl_callback_ptr_9_3_stdcall),PTR2NUM(rb_dl_callback_ptr_10_3_stdcall),PTR2NUM(rb_dl_callback_ptr_11_3_stdcall),PTR2NUM(rb_dl_callback_ptr_12_3_stdcall),PTR2NUM(rb_dl_callback_ptr_13_3_stdcall),PTR2NUM(rb_dl_callback_ptr_14_3_stdcall),PTR2NUM(rb_dl_callback_ptr_15_3_stdcall),PTR2NUM(rb_dl_callback_ptr_16_3_stdcall),PTR2NUM(rb_dl_callback_ptr_17_3_stdcall),PTR2NUM(rb_dl_callback_ptr_18_3_stdcall),PTR2NUM(rb_dl_callback_ptr_19_3_stdcall),PTR2NUM(rb_dl_callback_ptr_0_4_stdcall),PTR2NUM(rb_dl_callback_ptr_1_4_stdcall),PTR2NUM(rb_dl_callback_ptr_2_4_stdcall),PTR2NUM(rb_dl_callback_ptr_3_4_stdcall),PTR2NUM(rb_dl_callback_ptr_4_4_stdcall),PTR2NUM(rb_dl_callback_ptr_5_4_stdcall),PTR2NUM(rb_dl_callback_ptr_6_4_stdcall),PTR2NUM(rb_dl_callback_ptr_7_4_stdcall),PTR2NUM(rb_dl_callback_ptr_8_4_stdcall),PTR2NUM(rb_dl_callback_ptr_9_4_stdcall),PTR2NUM(rb_dl_callback_ptr_10_4_stdcall),PTR2NUM(rb_dl_callback_ptr_11_4_stdcall),PTR2NUM(rb_dl_callback_ptr_12_4_stdcall),PTR2NUM(rb_dl_callback_ptr_13_4_stdcall),PTR2NUM(rb_dl_callback_ptr_14_4_stdcall),PTR2NUM(rb_dl_callback_ptr_15_4_stdcall),PTR2NUM(rb_dl_callback_ptr_16_4_stdcall),PTR2NUM(rb_dl_callback_ptr_17_4_stdcall),PTR2NUM(rb_dl_callback_ptr_18_4_stdcall),PTR2NUM(rb_dl_callback_ptr_19_4_stdcall)));
+}
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static char
+FUNC_CDECL(rb_dl_callback_char_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_CDECL(rb_dl_callback_char_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 2), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+
+static char
+FUNC_STDCALL(rb_dl_callback_char_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 2), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2CHR(ret);
+}
+
+void
+rb_dl_init_callbacks_2()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_char_0_0_cdecl),PTR2NUM(rb_dl_callback_char_1_0_cdecl),PTR2NUM(rb_dl_callback_char_2_0_cdecl),PTR2NUM(rb_dl_callback_char_3_0_cdecl),PTR2NUM(rb_dl_callback_char_4_0_cdecl),PTR2NUM(rb_dl_callback_char_5_0_cdecl),PTR2NUM(rb_dl_callback_char_6_0_cdecl),PTR2NUM(rb_dl_callback_char_7_0_cdecl),PTR2NUM(rb_dl_callback_char_8_0_cdecl),PTR2NUM(rb_dl_callback_char_9_0_cdecl),PTR2NUM(rb_dl_callback_char_10_0_cdecl),PTR2NUM(rb_dl_callback_char_11_0_cdecl),PTR2NUM(rb_dl_callback_char_12_0_cdecl),PTR2NUM(rb_dl_callback_char_13_0_cdecl),PTR2NUM(rb_dl_callback_char_14_0_cdecl),PTR2NUM(rb_dl_callback_char_15_0_cdecl),PTR2NUM(rb_dl_callback_char_16_0_cdecl),PTR2NUM(rb_dl_callback_char_17_0_cdecl),PTR2NUM(rb_dl_callback_char_18_0_cdecl),PTR2NUM(rb_dl_callback_char_19_0_cdecl),PTR2NUM(rb_dl_callback_char_0_1_cdecl),PTR2NUM(rb_dl_callback_char_1_1_cdecl),PTR2NUM(rb_dl_callback_char_2_1_cdecl),PTR2NUM(rb_dl_callback_char_3_1_cdecl),PTR2NUM(rb_dl_callback_char_4_1_cdecl),PTR2NUM(rb_dl_callback_char_5_1_cdecl),PTR2NUM(rb_dl_callback_char_6_1_cdecl),PTR2NUM(rb_dl_callback_char_7_1_cdecl),PTR2NUM(rb_dl_callback_char_8_1_cdecl),PTR2NUM(rb_dl_callback_char_9_1_cdecl),PTR2NUM(rb_dl_callback_char_10_1_cdecl),PTR2NUM(rb_dl_callback_char_11_1_cdecl),PTR2NUM(rb_dl_callback_char_12_1_cdecl),PTR2NUM(rb_dl_callback_char_13_1_cdecl),PTR2NUM(rb_dl_callback_char_14_1_cdecl),PTR2NUM(rb_dl_callback_char_15_1_cdecl),PTR2NUM(rb_dl_callback_char_16_1_cdecl),PTR2NUM(rb_dl_callback_char_17_1_cdecl),PTR2NUM(rb_dl_callback_char_18_1_cdecl),PTR2NUM(rb_dl_callback_char_19_1_cdecl),PTR2NUM(rb_dl_callback_char_0_2_cdecl),PTR2NUM(rb_dl_callback_char_1_2_cdecl),PTR2NUM(rb_dl_callback_char_2_2_cdecl),PTR2NUM(rb_dl_callback_char_3_2_cdecl),PTR2NUM(rb_dl_callback_char_4_2_cdecl),PTR2NUM(rb_dl_callback_char_5_2_cdecl),PTR2NUM(rb_dl_callback_char_6_2_cdecl),PTR2NUM(rb_dl_callback_char_7_2_cdecl),PTR2NUM(rb_dl_callback_char_8_2_cdecl),PTR2NUM(rb_dl_callback_char_9_2_cdecl),PTR2NUM(rb_dl_callback_char_10_2_cdecl),PTR2NUM(rb_dl_callback_char_11_2_cdecl),PTR2NUM(rb_dl_callback_char_12_2_cdecl),PTR2NUM(rb_dl_callback_char_13_2_cdecl),PTR2NUM(rb_dl_callback_char_14_2_cdecl),PTR2NUM(rb_dl_callback_char_15_2_cdecl),PTR2NUM(rb_dl_callback_char_16_2_cdecl),PTR2NUM(rb_dl_callback_char_17_2_cdecl),PTR2NUM(rb_dl_callback_char_18_2_cdecl),PTR2NUM(rb_dl_callback_char_19_2_cdecl),PTR2NUM(rb_dl_callback_char_0_3_cdecl),PTR2NUM(rb_dl_callback_char_1_3_cdecl),PTR2NUM(rb_dl_callback_char_2_3_cdecl),PTR2NUM(rb_dl_callback_char_3_3_cdecl),PTR2NUM(rb_dl_callback_char_4_3_cdecl),PTR2NUM(rb_dl_callback_char_5_3_cdecl),PTR2NUM(rb_dl_callback_char_6_3_cdecl),PTR2NUM(rb_dl_callback_char_7_3_cdecl),PTR2NUM(rb_dl_callback_char_8_3_cdecl),PTR2NUM(rb_dl_callback_char_9_3_cdecl),PTR2NUM(rb_dl_callback_char_10_3_cdecl),PTR2NUM(rb_dl_callback_char_11_3_cdecl),PTR2NUM(rb_dl_callback_char_12_3_cdecl),PTR2NUM(rb_dl_callback_char_13_3_cdecl),PTR2NUM(rb_dl_callback_char_14_3_cdecl),PTR2NUM(rb_dl_callback_char_15_3_cdecl),PTR2NUM(rb_dl_callback_char_16_3_cdecl),PTR2NUM(rb_dl_callback_char_17_3_cdecl),PTR2NUM(rb_dl_callback_char_18_3_cdecl),PTR2NUM(rb_dl_callback_char_19_3_cdecl),PTR2NUM(rb_dl_callback_char_0_4_cdecl),PTR2NUM(rb_dl_callback_char_1_4_cdecl),PTR2NUM(rb_dl_callback_char_2_4_cdecl),PTR2NUM(rb_dl_callback_char_3_4_cdecl),PTR2NUM(rb_dl_callback_char_4_4_cdecl),PTR2NUM(rb_dl_callback_char_5_4_cdecl),PTR2NUM(rb_dl_callback_char_6_4_cdecl),PTR2NUM(rb_dl_callback_char_7_4_cdecl),PTR2NUM(rb_dl_callback_char_8_4_cdecl),PTR2NUM(rb_dl_callback_char_9_4_cdecl),PTR2NUM(rb_dl_callback_char_10_4_cdecl),PTR2NUM(rb_dl_callback_char_11_4_cdecl),PTR2NUM(rb_dl_callback_char_12_4_cdecl),PTR2NUM(rb_dl_callback_char_13_4_cdecl),PTR2NUM(rb_dl_callback_char_14_4_cdecl),PTR2NUM(rb_dl_callback_char_15_4_cdecl),PTR2NUM(rb_dl_callback_char_16_4_cdecl),PTR2NUM(rb_dl_callback_char_17_4_cdecl),PTR2NUM(rb_dl_callback_char_18_4_cdecl),PTR2NUM(rb_dl_callback_char_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_char_0_0_stdcall),PTR2NUM(rb_dl_callback_char_1_0_stdcall),PTR2NUM(rb_dl_callback_char_2_0_stdcall),PTR2NUM(rb_dl_callback_char_3_0_stdcall),PTR2NUM(rb_dl_callback_char_4_0_stdcall),PTR2NUM(rb_dl_callback_char_5_0_stdcall),PTR2NUM(rb_dl_callback_char_6_0_stdcall),PTR2NUM(rb_dl_callback_char_7_0_stdcall),PTR2NUM(rb_dl_callback_char_8_0_stdcall),PTR2NUM(rb_dl_callback_char_9_0_stdcall),PTR2NUM(rb_dl_callback_char_10_0_stdcall),PTR2NUM(rb_dl_callback_char_11_0_stdcall),PTR2NUM(rb_dl_callback_char_12_0_stdcall),PTR2NUM(rb_dl_callback_char_13_0_stdcall),PTR2NUM(rb_dl_callback_char_14_0_stdcall),PTR2NUM(rb_dl_callback_char_15_0_stdcall),PTR2NUM(rb_dl_callback_char_16_0_stdcall),PTR2NUM(rb_dl_callback_char_17_0_stdcall),PTR2NUM(rb_dl_callback_char_18_0_stdcall),PTR2NUM(rb_dl_callback_char_19_0_stdcall),PTR2NUM(rb_dl_callback_char_0_1_stdcall),PTR2NUM(rb_dl_callback_char_1_1_stdcall),PTR2NUM(rb_dl_callback_char_2_1_stdcall),PTR2NUM(rb_dl_callback_char_3_1_stdcall),PTR2NUM(rb_dl_callback_char_4_1_stdcall),PTR2NUM(rb_dl_callback_char_5_1_stdcall),PTR2NUM(rb_dl_callback_char_6_1_stdcall),PTR2NUM(rb_dl_callback_char_7_1_stdcall),PTR2NUM(rb_dl_callback_char_8_1_stdcall),PTR2NUM(rb_dl_callback_char_9_1_stdcall),PTR2NUM(rb_dl_callback_char_10_1_stdcall),PTR2NUM(rb_dl_callback_char_11_1_stdcall),PTR2NUM(rb_dl_callback_char_12_1_stdcall),PTR2NUM(rb_dl_callback_char_13_1_stdcall),PTR2NUM(rb_dl_callback_char_14_1_stdcall),PTR2NUM(rb_dl_callback_char_15_1_stdcall),PTR2NUM(rb_dl_callback_char_16_1_stdcall),PTR2NUM(rb_dl_callback_char_17_1_stdcall),PTR2NUM(rb_dl_callback_char_18_1_stdcall),PTR2NUM(rb_dl_callback_char_19_1_stdcall),PTR2NUM(rb_dl_callback_char_0_2_stdcall),PTR2NUM(rb_dl_callback_char_1_2_stdcall),PTR2NUM(rb_dl_callback_char_2_2_stdcall),PTR2NUM(rb_dl_callback_char_3_2_stdcall),PTR2NUM(rb_dl_callback_char_4_2_stdcall),PTR2NUM(rb_dl_callback_char_5_2_stdcall),PTR2NUM(rb_dl_callback_char_6_2_stdcall),PTR2NUM(rb_dl_callback_char_7_2_stdcall),PTR2NUM(rb_dl_callback_char_8_2_stdcall),PTR2NUM(rb_dl_callback_char_9_2_stdcall),PTR2NUM(rb_dl_callback_char_10_2_stdcall),PTR2NUM(rb_dl_callback_char_11_2_stdcall),PTR2NUM(rb_dl_callback_char_12_2_stdcall),PTR2NUM(rb_dl_callback_char_13_2_stdcall),PTR2NUM(rb_dl_callback_char_14_2_stdcall),PTR2NUM(rb_dl_callback_char_15_2_stdcall),PTR2NUM(rb_dl_callback_char_16_2_stdcall),PTR2NUM(rb_dl_callback_char_17_2_stdcall),PTR2NUM(rb_dl_callback_char_18_2_stdcall),PTR2NUM(rb_dl_callback_char_19_2_stdcall),PTR2NUM(rb_dl_callback_char_0_3_stdcall),PTR2NUM(rb_dl_callback_char_1_3_stdcall),PTR2NUM(rb_dl_callback_char_2_3_stdcall),PTR2NUM(rb_dl_callback_char_3_3_stdcall),PTR2NUM(rb_dl_callback_char_4_3_stdcall),PTR2NUM(rb_dl_callback_char_5_3_stdcall),PTR2NUM(rb_dl_callback_char_6_3_stdcall),PTR2NUM(rb_dl_callback_char_7_3_stdcall),PTR2NUM(rb_dl_callback_char_8_3_stdcall),PTR2NUM(rb_dl_callback_char_9_3_stdcall),PTR2NUM(rb_dl_callback_char_10_3_stdcall),PTR2NUM(rb_dl_callback_char_11_3_stdcall),PTR2NUM(rb_dl_callback_char_12_3_stdcall),PTR2NUM(rb_dl_callback_char_13_3_stdcall),PTR2NUM(rb_dl_callback_char_14_3_stdcall),PTR2NUM(rb_dl_callback_char_15_3_stdcall),PTR2NUM(rb_dl_callback_char_16_3_stdcall),PTR2NUM(rb_dl_callback_char_17_3_stdcall),PTR2NUM(rb_dl_callback_char_18_3_stdcall),PTR2NUM(rb_dl_callback_char_19_3_stdcall),PTR2NUM(rb_dl_callback_char_0_4_stdcall),PTR2NUM(rb_dl_callback_char_1_4_stdcall),PTR2NUM(rb_dl_callback_char_2_4_stdcall),PTR2NUM(rb_dl_callback_char_3_4_stdcall),PTR2NUM(rb_dl_callback_char_4_4_stdcall),PTR2NUM(rb_dl_callback_char_5_4_stdcall),PTR2NUM(rb_dl_callback_char_6_4_stdcall),PTR2NUM(rb_dl_callback_char_7_4_stdcall),PTR2NUM(rb_dl_callback_char_8_4_stdcall),PTR2NUM(rb_dl_callback_char_9_4_stdcall),PTR2NUM(rb_dl_callback_char_10_4_stdcall),PTR2NUM(rb_dl_callback_char_11_4_stdcall),PTR2NUM(rb_dl_callback_char_12_4_stdcall),PTR2NUM(rb_dl_callback_char_13_4_stdcall),PTR2NUM(rb_dl_callback_char_14_4_stdcall),PTR2NUM(rb_dl_callback_char_15_4_stdcall),PTR2NUM(rb_dl_callback_char_16_4_stdcall),PTR2NUM(rb_dl_callback_char_17_4_stdcall),PTR2NUM(rb_dl_callback_char_18_4_stdcall),PTR2NUM(rb_dl_callback_char_19_4_stdcall)));
+}
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static short
+FUNC_CDECL(rb_dl_callback_short_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_CDECL(rb_dl_callback_short_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 3), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static short
+FUNC_STDCALL(rb_dl_callback_short_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 3), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+void
+rb_dl_init_callbacks_3()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_short_0_0_cdecl),PTR2NUM(rb_dl_callback_short_1_0_cdecl),PTR2NUM(rb_dl_callback_short_2_0_cdecl),PTR2NUM(rb_dl_callback_short_3_0_cdecl),PTR2NUM(rb_dl_callback_short_4_0_cdecl),PTR2NUM(rb_dl_callback_short_5_0_cdecl),PTR2NUM(rb_dl_callback_short_6_0_cdecl),PTR2NUM(rb_dl_callback_short_7_0_cdecl),PTR2NUM(rb_dl_callback_short_8_0_cdecl),PTR2NUM(rb_dl_callback_short_9_0_cdecl),PTR2NUM(rb_dl_callback_short_10_0_cdecl),PTR2NUM(rb_dl_callback_short_11_0_cdecl),PTR2NUM(rb_dl_callback_short_12_0_cdecl),PTR2NUM(rb_dl_callback_short_13_0_cdecl),PTR2NUM(rb_dl_callback_short_14_0_cdecl),PTR2NUM(rb_dl_callback_short_15_0_cdecl),PTR2NUM(rb_dl_callback_short_16_0_cdecl),PTR2NUM(rb_dl_callback_short_17_0_cdecl),PTR2NUM(rb_dl_callback_short_18_0_cdecl),PTR2NUM(rb_dl_callback_short_19_0_cdecl),PTR2NUM(rb_dl_callback_short_0_1_cdecl),PTR2NUM(rb_dl_callback_short_1_1_cdecl),PTR2NUM(rb_dl_callback_short_2_1_cdecl),PTR2NUM(rb_dl_callback_short_3_1_cdecl),PTR2NUM(rb_dl_callback_short_4_1_cdecl),PTR2NUM(rb_dl_callback_short_5_1_cdecl),PTR2NUM(rb_dl_callback_short_6_1_cdecl),PTR2NUM(rb_dl_callback_short_7_1_cdecl),PTR2NUM(rb_dl_callback_short_8_1_cdecl),PTR2NUM(rb_dl_callback_short_9_1_cdecl),PTR2NUM(rb_dl_callback_short_10_1_cdecl),PTR2NUM(rb_dl_callback_short_11_1_cdecl),PTR2NUM(rb_dl_callback_short_12_1_cdecl),PTR2NUM(rb_dl_callback_short_13_1_cdecl),PTR2NUM(rb_dl_callback_short_14_1_cdecl),PTR2NUM(rb_dl_callback_short_15_1_cdecl),PTR2NUM(rb_dl_callback_short_16_1_cdecl),PTR2NUM(rb_dl_callback_short_17_1_cdecl),PTR2NUM(rb_dl_callback_short_18_1_cdecl),PTR2NUM(rb_dl_callback_short_19_1_cdecl),PTR2NUM(rb_dl_callback_short_0_2_cdecl),PTR2NUM(rb_dl_callback_short_1_2_cdecl),PTR2NUM(rb_dl_callback_short_2_2_cdecl),PTR2NUM(rb_dl_callback_short_3_2_cdecl),PTR2NUM(rb_dl_callback_short_4_2_cdecl),PTR2NUM(rb_dl_callback_short_5_2_cdecl),PTR2NUM(rb_dl_callback_short_6_2_cdecl),PTR2NUM(rb_dl_callback_short_7_2_cdecl),PTR2NUM(rb_dl_callback_short_8_2_cdecl),PTR2NUM(rb_dl_callback_short_9_2_cdecl),PTR2NUM(rb_dl_callback_short_10_2_cdecl),PTR2NUM(rb_dl_callback_short_11_2_cdecl),PTR2NUM(rb_dl_callback_short_12_2_cdecl),PTR2NUM(rb_dl_callback_short_13_2_cdecl),PTR2NUM(rb_dl_callback_short_14_2_cdecl),PTR2NUM(rb_dl_callback_short_15_2_cdecl),PTR2NUM(rb_dl_callback_short_16_2_cdecl),PTR2NUM(rb_dl_callback_short_17_2_cdecl),PTR2NUM(rb_dl_callback_short_18_2_cdecl),PTR2NUM(rb_dl_callback_short_19_2_cdecl),PTR2NUM(rb_dl_callback_short_0_3_cdecl),PTR2NUM(rb_dl_callback_short_1_3_cdecl),PTR2NUM(rb_dl_callback_short_2_3_cdecl),PTR2NUM(rb_dl_callback_short_3_3_cdecl),PTR2NUM(rb_dl_callback_short_4_3_cdecl),PTR2NUM(rb_dl_callback_short_5_3_cdecl),PTR2NUM(rb_dl_callback_short_6_3_cdecl),PTR2NUM(rb_dl_callback_short_7_3_cdecl),PTR2NUM(rb_dl_callback_short_8_3_cdecl),PTR2NUM(rb_dl_callback_short_9_3_cdecl),PTR2NUM(rb_dl_callback_short_10_3_cdecl),PTR2NUM(rb_dl_callback_short_11_3_cdecl),PTR2NUM(rb_dl_callback_short_12_3_cdecl),PTR2NUM(rb_dl_callback_short_13_3_cdecl),PTR2NUM(rb_dl_callback_short_14_3_cdecl),PTR2NUM(rb_dl_callback_short_15_3_cdecl),PTR2NUM(rb_dl_callback_short_16_3_cdecl),PTR2NUM(rb_dl_callback_short_17_3_cdecl),PTR2NUM(rb_dl_callback_short_18_3_cdecl),PTR2NUM(rb_dl_callback_short_19_3_cdecl),PTR2NUM(rb_dl_callback_short_0_4_cdecl),PTR2NUM(rb_dl_callback_short_1_4_cdecl),PTR2NUM(rb_dl_callback_short_2_4_cdecl),PTR2NUM(rb_dl_callback_short_3_4_cdecl),PTR2NUM(rb_dl_callback_short_4_4_cdecl),PTR2NUM(rb_dl_callback_short_5_4_cdecl),PTR2NUM(rb_dl_callback_short_6_4_cdecl),PTR2NUM(rb_dl_callback_short_7_4_cdecl),PTR2NUM(rb_dl_callback_short_8_4_cdecl),PTR2NUM(rb_dl_callback_short_9_4_cdecl),PTR2NUM(rb_dl_callback_short_10_4_cdecl),PTR2NUM(rb_dl_callback_short_11_4_cdecl),PTR2NUM(rb_dl_callback_short_12_4_cdecl),PTR2NUM(rb_dl_callback_short_13_4_cdecl),PTR2NUM(rb_dl_callback_short_14_4_cdecl),PTR2NUM(rb_dl_callback_short_15_4_cdecl),PTR2NUM(rb_dl_callback_short_16_4_cdecl),PTR2NUM(rb_dl_callback_short_17_4_cdecl),PTR2NUM(rb_dl_callback_short_18_4_cdecl),PTR2NUM(rb_dl_callback_short_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_short_0_0_stdcall),PTR2NUM(rb_dl_callback_short_1_0_stdcall),PTR2NUM(rb_dl_callback_short_2_0_stdcall),PTR2NUM(rb_dl_callback_short_3_0_stdcall),PTR2NUM(rb_dl_callback_short_4_0_stdcall),PTR2NUM(rb_dl_callback_short_5_0_stdcall),PTR2NUM(rb_dl_callback_short_6_0_stdcall),PTR2NUM(rb_dl_callback_short_7_0_stdcall),PTR2NUM(rb_dl_callback_short_8_0_stdcall),PTR2NUM(rb_dl_callback_short_9_0_stdcall),PTR2NUM(rb_dl_callback_short_10_0_stdcall),PTR2NUM(rb_dl_callback_short_11_0_stdcall),PTR2NUM(rb_dl_callback_short_12_0_stdcall),PTR2NUM(rb_dl_callback_short_13_0_stdcall),PTR2NUM(rb_dl_callback_short_14_0_stdcall),PTR2NUM(rb_dl_callback_short_15_0_stdcall),PTR2NUM(rb_dl_callback_short_16_0_stdcall),PTR2NUM(rb_dl_callback_short_17_0_stdcall),PTR2NUM(rb_dl_callback_short_18_0_stdcall),PTR2NUM(rb_dl_callback_short_19_0_stdcall),PTR2NUM(rb_dl_callback_short_0_1_stdcall),PTR2NUM(rb_dl_callback_short_1_1_stdcall),PTR2NUM(rb_dl_callback_short_2_1_stdcall),PTR2NUM(rb_dl_callback_short_3_1_stdcall),PTR2NUM(rb_dl_callback_short_4_1_stdcall),PTR2NUM(rb_dl_callback_short_5_1_stdcall),PTR2NUM(rb_dl_callback_short_6_1_stdcall),PTR2NUM(rb_dl_callback_short_7_1_stdcall),PTR2NUM(rb_dl_callback_short_8_1_stdcall),PTR2NUM(rb_dl_callback_short_9_1_stdcall),PTR2NUM(rb_dl_callback_short_10_1_stdcall),PTR2NUM(rb_dl_callback_short_11_1_stdcall),PTR2NUM(rb_dl_callback_short_12_1_stdcall),PTR2NUM(rb_dl_callback_short_13_1_stdcall),PTR2NUM(rb_dl_callback_short_14_1_stdcall),PTR2NUM(rb_dl_callback_short_15_1_stdcall),PTR2NUM(rb_dl_callback_short_16_1_stdcall),PTR2NUM(rb_dl_callback_short_17_1_stdcall),PTR2NUM(rb_dl_callback_short_18_1_stdcall),PTR2NUM(rb_dl_callback_short_19_1_stdcall),PTR2NUM(rb_dl_callback_short_0_2_stdcall),PTR2NUM(rb_dl_callback_short_1_2_stdcall),PTR2NUM(rb_dl_callback_short_2_2_stdcall),PTR2NUM(rb_dl_callback_short_3_2_stdcall),PTR2NUM(rb_dl_callback_short_4_2_stdcall),PTR2NUM(rb_dl_callback_short_5_2_stdcall),PTR2NUM(rb_dl_callback_short_6_2_stdcall),PTR2NUM(rb_dl_callback_short_7_2_stdcall),PTR2NUM(rb_dl_callback_short_8_2_stdcall),PTR2NUM(rb_dl_callback_short_9_2_stdcall),PTR2NUM(rb_dl_callback_short_10_2_stdcall),PTR2NUM(rb_dl_callback_short_11_2_stdcall),PTR2NUM(rb_dl_callback_short_12_2_stdcall),PTR2NUM(rb_dl_callback_short_13_2_stdcall),PTR2NUM(rb_dl_callback_short_14_2_stdcall),PTR2NUM(rb_dl_callback_short_15_2_stdcall),PTR2NUM(rb_dl_callback_short_16_2_stdcall),PTR2NUM(rb_dl_callback_short_17_2_stdcall),PTR2NUM(rb_dl_callback_short_18_2_stdcall),PTR2NUM(rb_dl_callback_short_19_2_stdcall),PTR2NUM(rb_dl_callback_short_0_3_stdcall),PTR2NUM(rb_dl_callback_short_1_3_stdcall),PTR2NUM(rb_dl_callback_short_2_3_stdcall),PTR2NUM(rb_dl_callback_short_3_3_stdcall),PTR2NUM(rb_dl_callback_short_4_3_stdcall),PTR2NUM(rb_dl_callback_short_5_3_stdcall),PTR2NUM(rb_dl_callback_short_6_3_stdcall),PTR2NUM(rb_dl_callback_short_7_3_stdcall),PTR2NUM(rb_dl_callback_short_8_3_stdcall),PTR2NUM(rb_dl_callback_short_9_3_stdcall),PTR2NUM(rb_dl_callback_short_10_3_stdcall),PTR2NUM(rb_dl_callback_short_11_3_stdcall),PTR2NUM(rb_dl_callback_short_12_3_stdcall),PTR2NUM(rb_dl_callback_short_13_3_stdcall),PTR2NUM(rb_dl_callback_short_14_3_stdcall),PTR2NUM(rb_dl_callback_short_15_3_stdcall),PTR2NUM(rb_dl_callback_short_16_3_stdcall),PTR2NUM(rb_dl_callback_short_17_3_stdcall),PTR2NUM(rb_dl_callback_short_18_3_stdcall),PTR2NUM(rb_dl_callback_short_19_3_stdcall),PTR2NUM(rb_dl_callback_short_0_4_stdcall),PTR2NUM(rb_dl_callback_short_1_4_stdcall),PTR2NUM(rb_dl_callback_short_2_4_stdcall),PTR2NUM(rb_dl_callback_short_3_4_stdcall),PTR2NUM(rb_dl_callback_short_4_4_stdcall),PTR2NUM(rb_dl_callback_short_5_4_stdcall),PTR2NUM(rb_dl_callback_short_6_4_stdcall),PTR2NUM(rb_dl_callback_short_7_4_stdcall),PTR2NUM(rb_dl_callback_short_8_4_stdcall),PTR2NUM(rb_dl_callback_short_9_4_stdcall),PTR2NUM(rb_dl_callback_short_10_4_stdcall),PTR2NUM(rb_dl_callback_short_11_4_stdcall),PTR2NUM(rb_dl_callback_short_12_4_stdcall),PTR2NUM(rb_dl_callback_short_13_4_stdcall),PTR2NUM(rb_dl_callback_short_14_4_stdcall),PTR2NUM(rb_dl_callback_short_15_4_stdcall),PTR2NUM(rb_dl_callback_short_16_4_stdcall),PTR2NUM(rb_dl_callback_short_17_4_stdcall),PTR2NUM(rb_dl_callback_short_18_4_stdcall),PTR2NUM(rb_dl_callback_short_19_4_stdcall)));
+}
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static int
+FUNC_CDECL(rb_dl_callback_int_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_CDECL(rb_dl_callback_int_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 4), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+
+static int
+FUNC_STDCALL(rb_dl_callback_int_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 4), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2INT(ret);
+}
+
+void
+rb_dl_init_callbacks_4()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_int_0_0_cdecl),PTR2NUM(rb_dl_callback_int_1_0_cdecl),PTR2NUM(rb_dl_callback_int_2_0_cdecl),PTR2NUM(rb_dl_callback_int_3_0_cdecl),PTR2NUM(rb_dl_callback_int_4_0_cdecl),PTR2NUM(rb_dl_callback_int_5_0_cdecl),PTR2NUM(rb_dl_callback_int_6_0_cdecl),PTR2NUM(rb_dl_callback_int_7_0_cdecl),PTR2NUM(rb_dl_callback_int_8_0_cdecl),PTR2NUM(rb_dl_callback_int_9_0_cdecl),PTR2NUM(rb_dl_callback_int_10_0_cdecl),PTR2NUM(rb_dl_callback_int_11_0_cdecl),PTR2NUM(rb_dl_callback_int_12_0_cdecl),PTR2NUM(rb_dl_callback_int_13_0_cdecl),PTR2NUM(rb_dl_callback_int_14_0_cdecl),PTR2NUM(rb_dl_callback_int_15_0_cdecl),PTR2NUM(rb_dl_callback_int_16_0_cdecl),PTR2NUM(rb_dl_callback_int_17_0_cdecl),PTR2NUM(rb_dl_callback_int_18_0_cdecl),PTR2NUM(rb_dl_callback_int_19_0_cdecl),PTR2NUM(rb_dl_callback_int_0_1_cdecl),PTR2NUM(rb_dl_callback_int_1_1_cdecl),PTR2NUM(rb_dl_callback_int_2_1_cdecl),PTR2NUM(rb_dl_callback_int_3_1_cdecl),PTR2NUM(rb_dl_callback_int_4_1_cdecl),PTR2NUM(rb_dl_callback_int_5_1_cdecl),PTR2NUM(rb_dl_callback_int_6_1_cdecl),PTR2NUM(rb_dl_callback_int_7_1_cdecl),PTR2NUM(rb_dl_callback_int_8_1_cdecl),PTR2NUM(rb_dl_callback_int_9_1_cdecl),PTR2NUM(rb_dl_callback_int_10_1_cdecl),PTR2NUM(rb_dl_callback_int_11_1_cdecl),PTR2NUM(rb_dl_callback_int_12_1_cdecl),PTR2NUM(rb_dl_callback_int_13_1_cdecl),PTR2NUM(rb_dl_callback_int_14_1_cdecl),PTR2NUM(rb_dl_callback_int_15_1_cdecl),PTR2NUM(rb_dl_callback_int_16_1_cdecl),PTR2NUM(rb_dl_callback_int_17_1_cdecl),PTR2NUM(rb_dl_callback_int_18_1_cdecl),PTR2NUM(rb_dl_callback_int_19_1_cdecl),PTR2NUM(rb_dl_callback_int_0_2_cdecl),PTR2NUM(rb_dl_callback_int_1_2_cdecl),PTR2NUM(rb_dl_callback_int_2_2_cdecl),PTR2NUM(rb_dl_callback_int_3_2_cdecl),PTR2NUM(rb_dl_callback_int_4_2_cdecl),PTR2NUM(rb_dl_callback_int_5_2_cdecl),PTR2NUM(rb_dl_callback_int_6_2_cdecl),PTR2NUM(rb_dl_callback_int_7_2_cdecl),PTR2NUM(rb_dl_callback_int_8_2_cdecl),PTR2NUM(rb_dl_callback_int_9_2_cdecl),PTR2NUM(rb_dl_callback_int_10_2_cdecl),PTR2NUM(rb_dl_callback_int_11_2_cdecl),PTR2NUM(rb_dl_callback_int_12_2_cdecl),PTR2NUM(rb_dl_callback_int_13_2_cdecl),PTR2NUM(rb_dl_callback_int_14_2_cdecl),PTR2NUM(rb_dl_callback_int_15_2_cdecl),PTR2NUM(rb_dl_callback_int_16_2_cdecl),PTR2NUM(rb_dl_callback_int_17_2_cdecl),PTR2NUM(rb_dl_callback_int_18_2_cdecl),PTR2NUM(rb_dl_callback_int_19_2_cdecl),PTR2NUM(rb_dl_callback_int_0_3_cdecl),PTR2NUM(rb_dl_callback_int_1_3_cdecl),PTR2NUM(rb_dl_callback_int_2_3_cdecl),PTR2NUM(rb_dl_callback_int_3_3_cdecl),PTR2NUM(rb_dl_callback_int_4_3_cdecl),PTR2NUM(rb_dl_callback_int_5_3_cdecl),PTR2NUM(rb_dl_callback_int_6_3_cdecl),PTR2NUM(rb_dl_callback_int_7_3_cdecl),PTR2NUM(rb_dl_callback_int_8_3_cdecl),PTR2NUM(rb_dl_callback_int_9_3_cdecl),PTR2NUM(rb_dl_callback_int_10_3_cdecl),PTR2NUM(rb_dl_callback_int_11_3_cdecl),PTR2NUM(rb_dl_callback_int_12_3_cdecl),PTR2NUM(rb_dl_callback_int_13_3_cdecl),PTR2NUM(rb_dl_callback_int_14_3_cdecl),PTR2NUM(rb_dl_callback_int_15_3_cdecl),PTR2NUM(rb_dl_callback_int_16_3_cdecl),PTR2NUM(rb_dl_callback_int_17_3_cdecl),PTR2NUM(rb_dl_callback_int_18_3_cdecl),PTR2NUM(rb_dl_callback_int_19_3_cdecl),PTR2NUM(rb_dl_callback_int_0_4_cdecl),PTR2NUM(rb_dl_callback_int_1_4_cdecl),PTR2NUM(rb_dl_callback_int_2_4_cdecl),PTR2NUM(rb_dl_callback_int_3_4_cdecl),PTR2NUM(rb_dl_callback_int_4_4_cdecl),PTR2NUM(rb_dl_callback_int_5_4_cdecl),PTR2NUM(rb_dl_callback_int_6_4_cdecl),PTR2NUM(rb_dl_callback_int_7_4_cdecl),PTR2NUM(rb_dl_callback_int_8_4_cdecl),PTR2NUM(rb_dl_callback_int_9_4_cdecl),PTR2NUM(rb_dl_callback_int_10_4_cdecl),PTR2NUM(rb_dl_callback_int_11_4_cdecl),PTR2NUM(rb_dl_callback_int_12_4_cdecl),PTR2NUM(rb_dl_callback_int_13_4_cdecl),PTR2NUM(rb_dl_callback_int_14_4_cdecl),PTR2NUM(rb_dl_callback_int_15_4_cdecl),PTR2NUM(rb_dl_callback_int_16_4_cdecl),PTR2NUM(rb_dl_callback_int_17_4_cdecl),PTR2NUM(rb_dl_callback_int_18_4_cdecl),PTR2NUM(rb_dl_callback_int_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_int_0_0_stdcall),PTR2NUM(rb_dl_callback_int_1_0_stdcall),PTR2NUM(rb_dl_callback_int_2_0_stdcall),PTR2NUM(rb_dl_callback_int_3_0_stdcall),PTR2NUM(rb_dl_callback_int_4_0_stdcall),PTR2NUM(rb_dl_callback_int_5_0_stdcall),PTR2NUM(rb_dl_callback_int_6_0_stdcall),PTR2NUM(rb_dl_callback_int_7_0_stdcall),PTR2NUM(rb_dl_callback_int_8_0_stdcall),PTR2NUM(rb_dl_callback_int_9_0_stdcall),PTR2NUM(rb_dl_callback_int_10_0_stdcall),PTR2NUM(rb_dl_callback_int_11_0_stdcall),PTR2NUM(rb_dl_callback_int_12_0_stdcall),PTR2NUM(rb_dl_callback_int_13_0_stdcall),PTR2NUM(rb_dl_callback_int_14_0_stdcall),PTR2NUM(rb_dl_callback_int_15_0_stdcall),PTR2NUM(rb_dl_callback_int_16_0_stdcall),PTR2NUM(rb_dl_callback_int_17_0_stdcall),PTR2NUM(rb_dl_callback_int_18_0_stdcall),PTR2NUM(rb_dl_callback_int_19_0_stdcall),PTR2NUM(rb_dl_callback_int_0_1_stdcall),PTR2NUM(rb_dl_callback_int_1_1_stdcall),PTR2NUM(rb_dl_callback_int_2_1_stdcall),PTR2NUM(rb_dl_callback_int_3_1_stdcall),PTR2NUM(rb_dl_callback_int_4_1_stdcall),PTR2NUM(rb_dl_callback_int_5_1_stdcall),PTR2NUM(rb_dl_callback_int_6_1_stdcall),PTR2NUM(rb_dl_callback_int_7_1_stdcall),PTR2NUM(rb_dl_callback_int_8_1_stdcall),PTR2NUM(rb_dl_callback_int_9_1_stdcall),PTR2NUM(rb_dl_callback_int_10_1_stdcall),PTR2NUM(rb_dl_callback_int_11_1_stdcall),PTR2NUM(rb_dl_callback_int_12_1_stdcall),PTR2NUM(rb_dl_callback_int_13_1_stdcall),PTR2NUM(rb_dl_callback_int_14_1_stdcall),PTR2NUM(rb_dl_callback_int_15_1_stdcall),PTR2NUM(rb_dl_callback_int_16_1_stdcall),PTR2NUM(rb_dl_callback_int_17_1_stdcall),PTR2NUM(rb_dl_callback_int_18_1_stdcall),PTR2NUM(rb_dl_callback_int_19_1_stdcall),PTR2NUM(rb_dl_callback_int_0_2_stdcall),PTR2NUM(rb_dl_callback_int_1_2_stdcall),PTR2NUM(rb_dl_callback_int_2_2_stdcall),PTR2NUM(rb_dl_callback_int_3_2_stdcall),PTR2NUM(rb_dl_callback_int_4_2_stdcall),PTR2NUM(rb_dl_callback_int_5_2_stdcall),PTR2NUM(rb_dl_callback_int_6_2_stdcall),PTR2NUM(rb_dl_callback_int_7_2_stdcall),PTR2NUM(rb_dl_callback_int_8_2_stdcall),PTR2NUM(rb_dl_callback_int_9_2_stdcall),PTR2NUM(rb_dl_callback_int_10_2_stdcall),PTR2NUM(rb_dl_callback_int_11_2_stdcall),PTR2NUM(rb_dl_callback_int_12_2_stdcall),PTR2NUM(rb_dl_callback_int_13_2_stdcall),PTR2NUM(rb_dl_callback_int_14_2_stdcall),PTR2NUM(rb_dl_callback_int_15_2_stdcall),PTR2NUM(rb_dl_callback_int_16_2_stdcall),PTR2NUM(rb_dl_callback_int_17_2_stdcall),PTR2NUM(rb_dl_callback_int_18_2_stdcall),PTR2NUM(rb_dl_callback_int_19_2_stdcall),PTR2NUM(rb_dl_callback_int_0_3_stdcall),PTR2NUM(rb_dl_callback_int_1_3_stdcall),PTR2NUM(rb_dl_callback_int_2_3_stdcall),PTR2NUM(rb_dl_callback_int_3_3_stdcall),PTR2NUM(rb_dl_callback_int_4_3_stdcall),PTR2NUM(rb_dl_callback_int_5_3_stdcall),PTR2NUM(rb_dl_callback_int_6_3_stdcall),PTR2NUM(rb_dl_callback_int_7_3_stdcall),PTR2NUM(rb_dl_callback_int_8_3_stdcall),PTR2NUM(rb_dl_callback_int_9_3_stdcall),PTR2NUM(rb_dl_callback_int_10_3_stdcall),PTR2NUM(rb_dl_callback_int_11_3_stdcall),PTR2NUM(rb_dl_callback_int_12_3_stdcall),PTR2NUM(rb_dl_callback_int_13_3_stdcall),PTR2NUM(rb_dl_callback_int_14_3_stdcall),PTR2NUM(rb_dl_callback_int_15_3_stdcall),PTR2NUM(rb_dl_callback_int_16_3_stdcall),PTR2NUM(rb_dl_callback_int_17_3_stdcall),PTR2NUM(rb_dl_callback_int_18_3_stdcall),PTR2NUM(rb_dl_callback_int_19_3_stdcall),PTR2NUM(rb_dl_callback_int_0_4_stdcall),PTR2NUM(rb_dl_callback_int_1_4_stdcall),PTR2NUM(rb_dl_callback_int_2_4_stdcall),PTR2NUM(rb_dl_callback_int_3_4_stdcall),PTR2NUM(rb_dl_callback_int_4_4_stdcall),PTR2NUM(rb_dl_callback_int_5_4_stdcall),PTR2NUM(rb_dl_callback_int_6_4_stdcall),PTR2NUM(rb_dl_callback_int_7_4_stdcall),PTR2NUM(rb_dl_callback_int_8_4_stdcall),PTR2NUM(rb_dl_callback_int_9_4_stdcall),PTR2NUM(rb_dl_callback_int_10_4_stdcall),PTR2NUM(rb_dl_callback_int_11_4_stdcall),PTR2NUM(rb_dl_callback_int_12_4_stdcall),PTR2NUM(rb_dl_callback_int_13_4_stdcall),PTR2NUM(rb_dl_callback_int_14_4_stdcall),PTR2NUM(rb_dl_callback_int_15_4_stdcall),PTR2NUM(rb_dl_callback_int_16_4_stdcall),PTR2NUM(rb_dl_callback_int_17_4_stdcall),PTR2NUM(rb_dl_callback_int_18_4_stdcall),PTR2NUM(rb_dl_callback_int_19_4_stdcall)));
+}
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static long
+FUNC_CDECL(rb_dl_callback_long_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_CDECL(rb_dl_callback_long_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 5), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+
+static long
+FUNC_STDCALL(rb_dl_callback_long_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 5), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LONG(ret);
+}
+
+void
+rb_dl_init_callbacks_5()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_long_0_0_cdecl),PTR2NUM(rb_dl_callback_long_1_0_cdecl),PTR2NUM(rb_dl_callback_long_2_0_cdecl),PTR2NUM(rb_dl_callback_long_3_0_cdecl),PTR2NUM(rb_dl_callback_long_4_0_cdecl),PTR2NUM(rb_dl_callback_long_5_0_cdecl),PTR2NUM(rb_dl_callback_long_6_0_cdecl),PTR2NUM(rb_dl_callback_long_7_0_cdecl),PTR2NUM(rb_dl_callback_long_8_0_cdecl),PTR2NUM(rb_dl_callback_long_9_0_cdecl),PTR2NUM(rb_dl_callback_long_10_0_cdecl),PTR2NUM(rb_dl_callback_long_11_0_cdecl),PTR2NUM(rb_dl_callback_long_12_0_cdecl),PTR2NUM(rb_dl_callback_long_13_0_cdecl),PTR2NUM(rb_dl_callback_long_14_0_cdecl),PTR2NUM(rb_dl_callback_long_15_0_cdecl),PTR2NUM(rb_dl_callback_long_16_0_cdecl),PTR2NUM(rb_dl_callback_long_17_0_cdecl),PTR2NUM(rb_dl_callback_long_18_0_cdecl),PTR2NUM(rb_dl_callback_long_19_0_cdecl),PTR2NUM(rb_dl_callback_long_0_1_cdecl),PTR2NUM(rb_dl_callback_long_1_1_cdecl),PTR2NUM(rb_dl_callback_long_2_1_cdecl),PTR2NUM(rb_dl_callback_long_3_1_cdecl),PTR2NUM(rb_dl_callback_long_4_1_cdecl),PTR2NUM(rb_dl_callback_long_5_1_cdecl),PTR2NUM(rb_dl_callback_long_6_1_cdecl),PTR2NUM(rb_dl_callback_long_7_1_cdecl),PTR2NUM(rb_dl_callback_long_8_1_cdecl),PTR2NUM(rb_dl_callback_long_9_1_cdecl),PTR2NUM(rb_dl_callback_long_10_1_cdecl),PTR2NUM(rb_dl_callback_long_11_1_cdecl),PTR2NUM(rb_dl_callback_long_12_1_cdecl),PTR2NUM(rb_dl_callback_long_13_1_cdecl),PTR2NUM(rb_dl_callback_long_14_1_cdecl),PTR2NUM(rb_dl_callback_long_15_1_cdecl),PTR2NUM(rb_dl_callback_long_16_1_cdecl),PTR2NUM(rb_dl_callback_long_17_1_cdecl),PTR2NUM(rb_dl_callback_long_18_1_cdecl),PTR2NUM(rb_dl_callback_long_19_1_cdecl),PTR2NUM(rb_dl_callback_long_0_2_cdecl),PTR2NUM(rb_dl_callback_long_1_2_cdecl),PTR2NUM(rb_dl_callback_long_2_2_cdecl),PTR2NUM(rb_dl_callback_long_3_2_cdecl),PTR2NUM(rb_dl_callback_long_4_2_cdecl),PTR2NUM(rb_dl_callback_long_5_2_cdecl),PTR2NUM(rb_dl_callback_long_6_2_cdecl),PTR2NUM(rb_dl_callback_long_7_2_cdecl),PTR2NUM(rb_dl_callback_long_8_2_cdecl),PTR2NUM(rb_dl_callback_long_9_2_cdecl),PTR2NUM(rb_dl_callback_long_10_2_cdecl),PTR2NUM(rb_dl_callback_long_11_2_cdecl),PTR2NUM(rb_dl_callback_long_12_2_cdecl),PTR2NUM(rb_dl_callback_long_13_2_cdecl),PTR2NUM(rb_dl_callback_long_14_2_cdecl),PTR2NUM(rb_dl_callback_long_15_2_cdecl),PTR2NUM(rb_dl_callback_long_16_2_cdecl),PTR2NUM(rb_dl_callback_long_17_2_cdecl),PTR2NUM(rb_dl_callback_long_18_2_cdecl),PTR2NUM(rb_dl_callback_long_19_2_cdecl),PTR2NUM(rb_dl_callback_long_0_3_cdecl),PTR2NUM(rb_dl_callback_long_1_3_cdecl),PTR2NUM(rb_dl_callback_long_2_3_cdecl),PTR2NUM(rb_dl_callback_long_3_3_cdecl),PTR2NUM(rb_dl_callback_long_4_3_cdecl),PTR2NUM(rb_dl_callback_long_5_3_cdecl),PTR2NUM(rb_dl_callback_long_6_3_cdecl),PTR2NUM(rb_dl_callback_long_7_3_cdecl),PTR2NUM(rb_dl_callback_long_8_3_cdecl),PTR2NUM(rb_dl_callback_long_9_3_cdecl),PTR2NUM(rb_dl_callback_long_10_3_cdecl),PTR2NUM(rb_dl_callback_long_11_3_cdecl),PTR2NUM(rb_dl_callback_long_12_3_cdecl),PTR2NUM(rb_dl_callback_long_13_3_cdecl),PTR2NUM(rb_dl_callback_long_14_3_cdecl),PTR2NUM(rb_dl_callback_long_15_3_cdecl),PTR2NUM(rb_dl_callback_long_16_3_cdecl),PTR2NUM(rb_dl_callback_long_17_3_cdecl),PTR2NUM(rb_dl_callback_long_18_3_cdecl),PTR2NUM(rb_dl_callback_long_19_3_cdecl),PTR2NUM(rb_dl_callback_long_0_4_cdecl),PTR2NUM(rb_dl_callback_long_1_4_cdecl),PTR2NUM(rb_dl_callback_long_2_4_cdecl),PTR2NUM(rb_dl_callback_long_3_4_cdecl),PTR2NUM(rb_dl_callback_long_4_4_cdecl),PTR2NUM(rb_dl_callback_long_5_4_cdecl),PTR2NUM(rb_dl_callback_long_6_4_cdecl),PTR2NUM(rb_dl_callback_long_7_4_cdecl),PTR2NUM(rb_dl_callback_long_8_4_cdecl),PTR2NUM(rb_dl_callback_long_9_4_cdecl),PTR2NUM(rb_dl_callback_long_10_4_cdecl),PTR2NUM(rb_dl_callback_long_11_4_cdecl),PTR2NUM(rb_dl_callback_long_12_4_cdecl),PTR2NUM(rb_dl_callback_long_13_4_cdecl),PTR2NUM(rb_dl_callback_long_14_4_cdecl),PTR2NUM(rb_dl_callback_long_15_4_cdecl),PTR2NUM(rb_dl_callback_long_16_4_cdecl),PTR2NUM(rb_dl_callback_long_17_4_cdecl),PTR2NUM(rb_dl_callback_long_18_4_cdecl),PTR2NUM(rb_dl_callback_long_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_long_0_0_stdcall),PTR2NUM(rb_dl_callback_long_1_0_stdcall),PTR2NUM(rb_dl_callback_long_2_0_stdcall),PTR2NUM(rb_dl_callback_long_3_0_stdcall),PTR2NUM(rb_dl_callback_long_4_0_stdcall),PTR2NUM(rb_dl_callback_long_5_0_stdcall),PTR2NUM(rb_dl_callback_long_6_0_stdcall),PTR2NUM(rb_dl_callback_long_7_0_stdcall),PTR2NUM(rb_dl_callback_long_8_0_stdcall),PTR2NUM(rb_dl_callback_long_9_0_stdcall),PTR2NUM(rb_dl_callback_long_10_0_stdcall),PTR2NUM(rb_dl_callback_long_11_0_stdcall),PTR2NUM(rb_dl_callback_long_12_0_stdcall),PTR2NUM(rb_dl_callback_long_13_0_stdcall),PTR2NUM(rb_dl_callback_long_14_0_stdcall),PTR2NUM(rb_dl_callback_long_15_0_stdcall),PTR2NUM(rb_dl_callback_long_16_0_stdcall),PTR2NUM(rb_dl_callback_long_17_0_stdcall),PTR2NUM(rb_dl_callback_long_18_0_stdcall),PTR2NUM(rb_dl_callback_long_19_0_stdcall),PTR2NUM(rb_dl_callback_long_0_1_stdcall),PTR2NUM(rb_dl_callback_long_1_1_stdcall),PTR2NUM(rb_dl_callback_long_2_1_stdcall),PTR2NUM(rb_dl_callback_long_3_1_stdcall),PTR2NUM(rb_dl_callback_long_4_1_stdcall),PTR2NUM(rb_dl_callback_long_5_1_stdcall),PTR2NUM(rb_dl_callback_long_6_1_stdcall),PTR2NUM(rb_dl_callback_long_7_1_stdcall),PTR2NUM(rb_dl_callback_long_8_1_stdcall),PTR2NUM(rb_dl_callback_long_9_1_stdcall),PTR2NUM(rb_dl_callback_long_10_1_stdcall),PTR2NUM(rb_dl_callback_long_11_1_stdcall),PTR2NUM(rb_dl_callback_long_12_1_stdcall),PTR2NUM(rb_dl_callback_long_13_1_stdcall),PTR2NUM(rb_dl_callback_long_14_1_stdcall),PTR2NUM(rb_dl_callback_long_15_1_stdcall),PTR2NUM(rb_dl_callback_long_16_1_stdcall),PTR2NUM(rb_dl_callback_long_17_1_stdcall),PTR2NUM(rb_dl_callback_long_18_1_stdcall),PTR2NUM(rb_dl_callback_long_19_1_stdcall),PTR2NUM(rb_dl_callback_long_0_2_stdcall),PTR2NUM(rb_dl_callback_long_1_2_stdcall),PTR2NUM(rb_dl_callback_long_2_2_stdcall),PTR2NUM(rb_dl_callback_long_3_2_stdcall),PTR2NUM(rb_dl_callback_long_4_2_stdcall),PTR2NUM(rb_dl_callback_long_5_2_stdcall),PTR2NUM(rb_dl_callback_long_6_2_stdcall),PTR2NUM(rb_dl_callback_long_7_2_stdcall),PTR2NUM(rb_dl_callback_long_8_2_stdcall),PTR2NUM(rb_dl_callback_long_9_2_stdcall),PTR2NUM(rb_dl_callback_long_10_2_stdcall),PTR2NUM(rb_dl_callback_long_11_2_stdcall),PTR2NUM(rb_dl_callback_long_12_2_stdcall),PTR2NUM(rb_dl_callback_long_13_2_stdcall),PTR2NUM(rb_dl_callback_long_14_2_stdcall),PTR2NUM(rb_dl_callback_long_15_2_stdcall),PTR2NUM(rb_dl_callback_long_16_2_stdcall),PTR2NUM(rb_dl_callback_long_17_2_stdcall),PTR2NUM(rb_dl_callback_long_18_2_stdcall),PTR2NUM(rb_dl_callback_long_19_2_stdcall),PTR2NUM(rb_dl_callback_long_0_3_stdcall),PTR2NUM(rb_dl_callback_long_1_3_stdcall),PTR2NUM(rb_dl_callback_long_2_3_stdcall),PTR2NUM(rb_dl_callback_long_3_3_stdcall),PTR2NUM(rb_dl_callback_long_4_3_stdcall),PTR2NUM(rb_dl_callback_long_5_3_stdcall),PTR2NUM(rb_dl_callback_long_6_3_stdcall),PTR2NUM(rb_dl_callback_long_7_3_stdcall),PTR2NUM(rb_dl_callback_long_8_3_stdcall),PTR2NUM(rb_dl_callback_long_9_3_stdcall),PTR2NUM(rb_dl_callback_long_10_3_stdcall),PTR2NUM(rb_dl_callback_long_11_3_stdcall),PTR2NUM(rb_dl_callback_long_12_3_stdcall),PTR2NUM(rb_dl_callback_long_13_3_stdcall),PTR2NUM(rb_dl_callback_long_14_3_stdcall),PTR2NUM(rb_dl_callback_long_15_3_stdcall),PTR2NUM(rb_dl_callback_long_16_3_stdcall),PTR2NUM(rb_dl_callback_long_17_3_stdcall),PTR2NUM(rb_dl_callback_long_18_3_stdcall),PTR2NUM(rb_dl_callback_long_19_3_stdcall),PTR2NUM(rb_dl_callback_long_0_4_stdcall),PTR2NUM(rb_dl_callback_long_1_4_stdcall),PTR2NUM(rb_dl_callback_long_2_4_stdcall),PTR2NUM(rb_dl_callback_long_3_4_stdcall),PTR2NUM(rb_dl_callback_long_4_4_stdcall),PTR2NUM(rb_dl_callback_long_5_4_stdcall),PTR2NUM(rb_dl_callback_long_6_4_stdcall),PTR2NUM(rb_dl_callback_long_7_4_stdcall),PTR2NUM(rb_dl_callback_long_8_4_stdcall),PTR2NUM(rb_dl_callback_long_9_4_stdcall),PTR2NUM(rb_dl_callback_long_10_4_stdcall),PTR2NUM(rb_dl_callback_long_11_4_stdcall),PTR2NUM(rb_dl_callback_long_12_4_stdcall),PTR2NUM(rb_dl_callback_long_13_4_stdcall),PTR2NUM(rb_dl_callback_long_14_4_stdcall),PTR2NUM(rb_dl_callback_long_15_4_stdcall),PTR2NUM(rb_dl_callback_long_16_4_stdcall),PTR2NUM(rb_dl_callback_long_17_4_stdcall),PTR2NUM(rb_dl_callback_long_18_4_stdcall),PTR2NUM(rb_dl_callback_long_19_4_stdcall)));
+}
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_CDECL(rb_dl_callback_long_long_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 6), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+
+static LONG_LONG
+FUNC_STDCALL(rb_dl_callback_long_long_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 6), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return NUM2LL(ret);
+}
+
+void
+rb_dl_init_callbacks_6()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_long_long_0_0_cdecl),PTR2NUM(rb_dl_callback_long_long_1_0_cdecl),PTR2NUM(rb_dl_callback_long_long_2_0_cdecl),PTR2NUM(rb_dl_callback_long_long_3_0_cdecl),PTR2NUM(rb_dl_callback_long_long_4_0_cdecl),PTR2NUM(rb_dl_callback_long_long_5_0_cdecl),PTR2NUM(rb_dl_callback_long_long_6_0_cdecl),PTR2NUM(rb_dl_callback_long_long_7_0_cdecl),PTR2NUM(rb_dl_callback_long_long_8_0_cdecl),PTR2NUM(rb_dl_callback_long_long_9_0_cdecl),PTR2NUM(rb_dl_callback_long_long_10_0_cdecl),PTR2NUM(rb_dl_callback_long_long_11_0_cdecl),PTR2NUM(rb_dl_callback_long_long_12_0_cdecl),PTR2NUM(rb_dl_callback_long_long_13_0_cdecl),PTR2NUM(rb_dl_callback_long_long_14_0_cdecl),PTR2NUM(rb_dl_callback_long_long_15_0_cdecl),PTR2NUM(rb_dl_callback_long_long_16_0_cdecl),PTR2NUM(rb_dl_callback_long_long_17_0_cdecl),PTR2NUM(rb_dl_callback_long_long_18_0_cdecl),PTR2NUM(rb_dl_callback_long_long_19_0_cdecl),PTR2NUM(rb_dl_callback_long_long_0_1_cdecl),PTR2NUM(rb_dl_callback_long_long_1_1_cdecl),PTR2NUM(rb_dl_callback_long_long_2_1_cdecl),PTR2NUM(rb_dl_callback_long_long_3_1_cdecl),PTR2NUM(rb_dl_callback_long_long_4_1_cdecl),PTR2NUM(rb_dl_callback_long_long_5_1_cdecl),PTR2NUM(rb_dl_callback_long_long_6_1_cdecl),PTR2NUM(rb_dl_callback_long_long_7_1_cdecl),PTR2NUM(rb_dl_callback_long_long_8_1_cdecl),PTR2NUM(rb_dl_callback_long_long_9_1_cdecl),PTR2NUM(rb_dl_callback_long_long_10_1_cdecl),PTR2NUM(rb_dl_callback_long_long_11_1_cdecl),PTR2NUM(rb_dl_callback_long_long_12_1_cdecl),PTR2NUM(rb_dl_callback_long_long_13_1_cdecl),PTR2NUM(rb_dl_callback_long_long_14_1_cdecl),PTR2NUM(rb_dl_callback_long_long_15_1_cdecl),PTR2NUM(rb_dl_callback_long_long_16_1_cdecl),PTR2NUM(rb_dl_callback_long_long_17_1_cdecl),PTR2NUM(rb_dl_callback_long_long_18_1_cdecl),PTR2NUM(rb_dl_callback_long_long_19_1_cdecl),PTR2NUM(rb_dl_callback_long_long_0_2_cdecl),PTR2NUM(rb_dl_callback_long_long_1_2_cdecl),PTR2NUM(rb_dl_callback_long_long_2_2_cdecl),PTR2NUM(rb_dl_callback_long_long_3_2_cdecl),PTR2NUM(rb_dl_callback_long_long_4_2_cdecl),PTR2NUM(rb_dl_callback_long_long_5_2_cdecl),PTR2NUM(rb_dl_callback_long_long_6_2_cdecl),PTR2NUM(rb_dl_callback_long_long_7_2_cdecl),PTR2NUM(rb_dl_callback_long_long_8_2_cdecl),PTR2NUM(rb_dl_callback_long_long_9_2_cdecl),PTR2NUM(rb_dl_callback_long_long_10_2_cdecl),PTR2NUM(rb_dl_callback_long_long_11_2_cdecl),PTR2NUM(rb_dl_callback_long_long_12_2_cdecl),PTR2NUM(rb_dl_callback_long_long_13_2_cdecl),PTR2NUM(rb_dl_callback_long_long_14_2_cdecl),PTR2NUM(rb_dl_callback_long_long_15_2_cdecl),PTR2NUM(rb_dl_callback_long_long_16_2_cdecl),PTR2NUM(rb_dl_callback_long_long_17_2_cdecl),PTR2NUM(rb_dl_callback_long_long_18_2_cdecl),PTR2NUM(rb_dl_callback_long_long_19_2_cdecl),PTR2NUM(rb_dl_callback_long_long_0_3_cdecl),PTR2NUM(rb_dl_callback_long_long_1_3_cdecl),PTR2NUM(rb_dl_callback_long_long_2_3_cdecl),PTR2NUM(rb_dl_callback_long_long_3_3_cdecl),PTR2NUM(rb_dl_callback_long_long_4_3_cdecl),PTR2NUM(rb_dl_callback_long_long_5_3_cdecl),PTR2NUM(rb_dl_callback_long_long_6_3_cdecl),PTR2NUM(rb_dl_callback_long_long_7_3_cdecl),PTR2NUM(rb_dl_callback_long_long_8_3_cdecl),PTR2NUM(rb_dl_callback_long_long_9_3_cdecl),PTR2NUM(rb_dl_callback_long_long_10_3_cdecl),PTR2NUM(rb_dl_callback_long_long_11_3_cdecl),PTR2NUM(rb_dl_callback_long_long_12_3_cdecl),PTR2NUM(rb_dl_callback_long_long_13_3_cdecl),PTR2NUM(rb_dl_callback_long_long_14_3_cdecl),PTR2NUM(rb_dl_callback_long_long_15_3_cdecl),PTR2NUM(rb_dl_callback_long_long_16_3_cdecl),PTR2NUM(rb_dl_callback_long_long_17_3_cdecl),PTR2NUM(rb_dl_callback_long_long_18_3_cdecl),PTR2NUM(rb_dl_callback_long_long_19_3_cdecl),PTR2NUM(rb_dl_callback_long_long_0_4_cdecl),PTR2NUM(rb_dl_callback_long_long_1_4_cdecl),PTR2NUM(rb_dl_callback_long_long_2_4_cdecl),PTR2NUM(rb_dl_callback_long_long_3_4_cdecl),PTR2NUM(rb_dl_callback_long_long_4_4_cdecl),PTR2NUM(rb_dl_callback_long_long_5_4_cdecl),PTR2NUM(rb_dl_callback_long_long_6_4_cdecl),PTR2NUM(rb_dl_callback_long_long_7_4_cdecl),PTR2NUM(rb_dl_callback_long_long_8_4_cdecl),PTR2NUM(rb_dl_callback_long_long_9_4_cdecl),PTR2NUM(rb_dl_callback_long_long_10_4_cdecl),PTR2NUM(rb_dl_callback_long_long_11_4_cdecl),PTR2NUM(rb_dl_callback_long_long_12_4_cdecl),PTR2NUM(rb_dl_callback_long_long_13_4_cdecl),PTR2NUM(rb_dl_callback_long_long_14_4_cdecl),PTR2NUM(rb_dl_callback_long_long_15_4_cdecl),PTR2NUM(rb_dl_callback_long_long_16_4_cdecl),PTR2NUM(rb_dl_callback_long_long_17_4_cdecl),PTR2NUM(rb_dl_callback_long_long_18_4_cdecl),PTR2NUM(rb_dl_callback_long_long_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_long_long_0_0_stdcall),PTR2NUM(rb_dl_callback_long_long_1_0_stdcall),PTR2NUM(rb_dl_callback_long_long_2_0_stdcall),PTR2NUM(rb_dl_callback_long_long_3_0_stdcall),PTR2NUM(rb_dl_callback_long_long_4_0_stdcall),PTR2NUM(rb_dl_callback_long_long_5_0_stdcall),PTR2NUM(rb_dl_callback_long_long_6_0_stdcall),PTR2NUM(rb_dl_callback_long_long_7_0_stdcall),PTR2NUM(rb_dl_callback_long_long_8_0_stdcall),PTR2NUM(rb_dl_callback_long_long_9_0_stdcall),PTR2NUM(rb_dl_callback_long_long_10_0_stdcall),PTR2NUM(rb_dl_callback_long_long_11_0_stdcall),PTR2NUM(rb_dl_callback_long_long_12_0_stdcall),PTR2NUM(rb_dl_callback_long_long_13_0_stdcall),PTR2NUM(rb_dl_callback_long_long_14_0_stdcall),PTR2NUM(rb_dl_callback_long_long_15_0_stdcall),PTR2NUM(rb_dl_callback_long_long_16_0_stdcall),PTR2NUM(rb_dl_callback_long_long_17_0_stdcall),PTR2NUM(rb_dl_callback_long_long_18_0_stdcall),PTR2NUM(rb_dl_callback_long_long_19_0_stdcall),PTR2NUM(rb_dl_callback_long_long_0_1_stdcall),PTR2NUM(rb_dl_callback_long_long_1_1_stdcall),PTR2NUM(rb_dl_callback_long_long_2_1_stdcall),PTR2NUM(rb_dl_callback_long_long_3_1_stdcall),PTR2NUM(rb_dl_callback_long_long_4_1_stdcall),PTR2NUM(rb_dl_callback_long_long_5_1_stdcall),PTR2NUM(rb_dl_callback_long_long_6_1_stdcall),PTR2NUM(rb_dl_callback_long_long_7_1_stdcall),PTR2NUM(rb_dl_callback_long_long_8_1_stdcall),PTR2NUM(rb_dl_callback_long_long_9_1_stdcall),PTR2NUM(rb_dl_callback_long_long_10_1_stdcall),PTR2NUM(rb_dl_callback_long_long_11_1_stdcall),PTR2NUM(rb_dl_callback_long_long_12_1_stdcall),PTR2NUM(rb_dl_callback_long_long_13_1_stdcall),PTR2NUM(rb_dl_callback_long_long_14_1_stdcall),PTR2NUM(rb_dl_callback_long_long_15_1_stdcall),PTR2NUM(rb_dl_callback_long_long_16_1_stdcall),PTR2NUM(rb_dl_callback_long_long_17_1_stdcall),PTR2NUM(rb_dl_callback_long_long_18_1_stdcall),PTR2NUM(rb_dl_callback_long_long_19_1_stdcall),PTR2NUM(rb_dl_callback_long_long_0_2_stdcall),PTR2NUM(rb_dl_callback_long_long_1_2_stdcall),PTR2NUM(rb_dl_callback_long_long_2_2_stdcall),PTR2NUM(rb_dl_callback_long_long_3_2_stdcall),PTR2NUM(rb_dl_callback_long_long_4_2_stdcall),PTR2NUM(rb_dl_callback_long_long_5_2_stdcall),PTR2NUM(rb_dl_callback_long_long_6_2_stdcall),PTR2NUM(rb_dl_callback_long_long_7_2_stdcall),PTR2NUM(rb_dl_callback_long_long_8_2_stdcall),PTR2NUM(rb_dl_callback_long_long_9_2_stdcall),PTR2NUM(rb_dl_callback_long_long_10_2_stdcall),PTR2NUM(rb_dl_callback_long_long_11_2_stdcall),PTR2NUM(rb_dl_callback_long_long_12_2_stdcall),PTR2NUM(rb_dl_callback_long_long_13_2_stdcall),PTR2NUM(rb_dl_callback_long_long_14_2_stdcall),PTR2NUM(rb_dl_callback_long_long_15_2_stdcall),PTR2NUM(rb_dl_callback_long_long_16_2_stdcall),PTR2NUM(rb_dl_callback_long_long_17_2_stdcall),PTR2NUM(rb_dl_callback_long_long_18_2_stdcall),PTR2NUM(rb_dl_callback_long_long_19_2_stdcall),PTR2NUM(rb_dl_callback_long_long_0_3_stdcall),PTR2NUM(rb_dl_callback_long_long_1_3_stdcall),PTR2NUM(rb_dl_callback_long_long_2_3_stdcall),PTR2NUM(rb_dl_callback_long_long_3_3_stdcall),PTR2NUM(rb_dl_callback_long_long_4_3_stdcall),PTR2NUM(rb_dl_callback_long_long_5_3_stdcall),PTR2NUM(rb_dl_callback_long_long_6_3_stdcall),PTR2NUM(rb_dl_callback_long_long_7_3_stdcall),PTR2NUM(rb_dl_callback_long_long_8_3_stdcall),PTR2NUM(rb_dl_callback_long_long_9_3_stdcall),PTR2NUM(rb_dl_callback_long_long_10_3_stdcall),PTR2NUM(rb_dl_callback_long_long_11_3_stdcall),PTR2NUM(rb_dl_callback_long_long_12_3_stdcall),PTR2NUM(rb_dl_callback_long_long_13_3_stdcall),PTR2NUM(rb_dl_callback_long_long_14_3_stdcall),PTR2NUM(rb_dl_callback_long_long_15_3_stdcall),PTR2NUM(rb_dl_callback_long_long_16_3_stdcall),PTR2NUM(rb_dl_callback_long_long_17_3_stdcall),PTR2NUM(rb_dl_callback_long_long_18_3_stdcall),PTR2NUM(rb_dl_callback_long_long_19_3_stdcall),PTR2NUM(rb_dl_callback_long_long_0_4_stdcall),PTR2NUM(rb_dl_callback_long_long_1_4_stdcall),PTR2NUM(rb_dl_callback_long_long_2_4_stdcall),PTR2NUM(rb_dl_callback_long_long_3_4_stdcall),PTR2NUM(rb_dl_callback_long_long_4_4_stdcall),PTR2NUM(rb_dl_callback_long_long_5_4_stdcall),PTR2NUM(rb_dl_callback_long_long_6_4_stdcall),PTR2NUM(rb_dl_callback_long_long_7_4_stdcall),PTR2NUM(rb_dl_callback_long_long_8_4_stdcall),PTR2NUM(rb_dl_callback_long_long_9_4_stdcall),PTR2NUM(rb_dl_callback_long_long_10_4_stdcall),PTR2NUM(rb_dl_callback_long_long_11_4_stdcall),PTR2NUM(rb_dl_callback_long_long_12_4_stdcall),PTR2NUM(rb_dl_callback_long_long_13_4_stdcall),PTR2NUM(rb_dl_callback_long_long_14_4_stdcall),PTR2NUM(rb_dl_callback_long_long_15_4_stdcall),PTR2NUM(rb_dl_callback_long_long_16_4_stdcall),PTR2NUM(rb_dl_callback_long_long_17_4_stdcall),PTR2NUM(rb_dl_callback_long_long_18_4_stdcall),PTR2NUM(rb_dl_callback_long_long_19_4_stdcall)));
+}
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static float
+FUNC_CDECL(rb_dl_callback_float_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_CDECL(rb_dl_callback_float_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 7), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static float
+FUNC_STDCALL(rb_dl_callback_float_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 7), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+void
+rb_dl_init_callbacks_7()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_float_0_0_cdecl),PTR2NUM(rb_dl_callback_float_1_0_cdecl),PTR2NUM(rb_dl_callback_float_2_0_cdecl),PTR2NUM(rb_dl_callback_float_3_0_cdecl),PTR2NUM(rb_dl_callback_float_4_0_cdecl),PTR2NUM(rb_dl_callback_float_5_0_cdecl),PTR2NUM(rb_dl_callback_float_6_0_cdecl),PTR2NUM(rb_dl_callback_float_7_0_cdecl),PTR2NUM(rb_dl_callback_float_8_0_cdecl),PTR2NUM(rb_dl_callback_float_9_0_cdecl),PTR2NUM(rb_dl_callback_float_10_0_cdecl),PTR2NUM(rb_dl_callback_float_11_0_cdecl),PTR2NUM(rb_dl_callback_float_12_0_cdecl),PTR2NUM(rb_dl_callback_float_13_0_cdecl),PTR2NUM(rb_dl_callback_float_14_0_cdecl),PTR2NUM(rb_dl_callback_float_15_0_cdecl),PTR2NUM(rb_dl_callback_float_16_0_cdecl),PTR2NUM(rb_dl_callback_float_17_0_cdecl),PTR2NUM(rb_dl_callback_float_18_0_cdecl),PTR2NUM(rb_dl_callback_float_19_0_cdecl),PTR2NUM(rb_dl_callback_float_0_1_cdecl),PTR2NUM(rb_dl_callback_float_1_1_cdecl),PTR2NUM(rb_dl_callback_float_2_1_cdecl),PTR2NUM(rb_dl_callback_float_3_1_cdecl),PTR2NUM(rb_dl_callback_float_4_1_cdecl),PTR2NUM(rb_dl_callback_float_5_1_cdecl),PTR2NUM(rb_dl_callback_float_6_1_cdecl),PTR2NUM(rb_dl_callback_float_7_1_cdecl),PTR2NUM(rb_dl_callback_float_8_1_cdecl),PTR2NUM(rb_dl_callback_float_9_1_cdecl),PTR2NUM(rb_dl_callback_float_10_1_cdecl),PTR2NUM(rb_dl_callback_float_11_1_cdecl),PTR2NUM(rb_dl_callback_float_12_1_cdecl),PTR2NUM(rb_dl_callback_float_13_1_cdecl),PTR2NUM(rb_dl_callback_float_14_1_cdecl),PTR2NUM(rb_dl_callback_float_15_1_cdecl),PTR2NUM(rb_dl_callback_float_16_1_cdecl),PTR2NUM(rb_dl_callback_float_17_1_cdecl),PTR2NUM(rb_dl_callback_float_18_1_cdecl),PTR2NUM(rb_dl_callback_float_19_1_cdecl),PTR2NUM(rb_dl_callback_float_0_2_cdecl),PTR2NUM(rb_dl_callback_float_1_2_cdecl),PTR2NUM(rb_dl_callback_float_2_2_cdecl),PTR2NUM(rb_dl_callback_float_3_2_cdecl),PTR2NUM(rb_dl_callback_float_4_2_cdecl),PTR2NUM(rb_dl_callback_float_5_2_cdecl),PTR2NUM(rb_dl_callback_float_6_2_cdecl),PTR2NUM(rb_dl_callback_float_7_2_cdecl),PTR2NUM(rb_dl_callback_float_8_2_cdecl),PTR2NUM(rb_dl_callback_float_9_2_cdecl),PTR2NUM(rb_dl_callback_float_10_2_cdecl),PTR2NUM(rb_dl_callback_float_11_2_cdecl),PTR2NUM(rb_dl_callback_float_12_2_cdecl),PTR2NUM(rb_dl_callback_float_13_2_cdecl),PTR2NUM(rb_dl_callback_float_14_2_cdecl),PTR2NUM(rb_dl_callback_float_15_2_cdecl),PTR2NUM(rb_dl_callback_float_16_2_cdecl),PTR2NUM(rb_dl_callback_float_17_2_cdecl),PTR2NUM(rb_dl_callback_float_18_2_cdecl),PTR2NUM(rb_dl_callback_float_19_2_cdecl),PTR2NUM(rb_dl_callback_float_0_3_cdecl),PTR2NUM(rb_dl_callback_float_1_3_cdecl),PTR2NUM(rb_dl_callback_float_2_3_cdecl),PTR2NUM(rb_dl_callback_float_3_3_cdecl),PTR2NUM(rb_dl_callback_float_4_3_cdecl),PTR2NUM(rb_dl_callback_float_5_3_cdecl),PTR2NUM(rb_dl_callback_float_6_3_cdecl),PTR2NUM(rb_dl_callback_float_7_3_cdecl),PTR2NUM(rb_dl_callback_float_8_3_cdecl),PTR2NUM(rb_dl_callback_float_9_3_cdecl),PTR2NUM(rb_dl_callback_float_10_3_cdecl),PTR2NUM(rb_dl_callback_float_11_3_cdecl),PTR2NUM(rb_dl_callback_float_12_3_cdecl),PTR2NUM(rb_dl_callback_float_13_3_cdecl),PTR2NUM(rb_dl_callback_float_14_3_cdecl),PTR2NUM(rb_dl_callback_float_15_3_cdecl),PTR2NUM(rb_dl_callback_float_16_3_cdecl),PTR2NUM(rb_dl_callback_float_17_3_cdecl),PTR2NUM(rb_dl_callback_float_18_3_cdecl),PTR2NUM(rb_dl_callback_float_19_3_cdecl),PTR2NUM(rb_dl_callback_float_0_4_cdecl),PTR2NUM(rb_dl_callback_float_1_4_cdecl),PTR2NUM(rb_dl_callback_float_2_4_cdecl),PTR2NUM(rb_dl_callback_float_3_4_cdecl),PTR2NUM(rb_dl_callback_float_4_4_cdecl),PTR2NUM(rb_dl_callback_float_5_4_cdecl),PTR2NUM(rb_dl_callback_float_6_4_cdecl),PTR2NUM(rb_dl_callback_float_7_4_cdecl),PTR2NUM(rb_dl_callback_float_8_4_cdecl),PTR2NUM(rb_dl_callback_float_9_4_cdecl),PTR2NUM(rb_dl_callback_float_10_4_cdecl),PTR2NUM(rb_dl_callback_float_11_4_cdecl),PTR2NUM(rb_dl_callback_float_12_4_cdecl),PTR2NUM(rb_dl_callback_float_13_4_cdecl),PTR2NUM(rb_dl_callback_float_14_4_cdecl),PTR2NUM(rb_dl_callback_float_15_4_cdecl),PTR2NUM(rb_dl_callback_float_16_4_cdecl),PTR2NUM(rb_dl_callback_float_17_4_cdecl),PTR2NUM(rb_dl_callback_float_18_4_cdecl),PTR2NUM(rb_dl_callback_float_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_float_0_0_stdcall),PTR2NUM(rb_dl_callback_float_1_0_stdcall),PTR2NUM(rb_dl_callback_float_2_0_stdcall),PTR2NUM(rb_dl_callback_float_3_0_stdcall),PTR2NUM(rb_dl_callback_float_4_0_stdcall),PTR2NUM(rb_dl_callback_float_5_0_stdcall),PTR2NUM(rb_dl_callback_float_6_0_stdcall),PTR2NUM(rb_dl_callback_float_7_0_stdcall),PTR2NUM(rb_dl_callback_float_8_0_stdcall),PTR2NUM(rb_dl_callback_float_9_0_stdcall),PTR2NUM(rb_dl_callback_float_10_0_stdcall),PTR2NUM(rb_dl_callback_float_11_0_stdcall),PTR2NUM(rb_dl_callback_float_12_0_stdcall),PTR2NUM(rb_dl_callback_float_13_0_stdcall),PTR2NUM(rb_dl_callback_float_14_0_stdcall),PTR2NUM(rb_dl_callback_float_15_0_stdcall),PTR2NUM(rb_dl_callback_float_16_0_stdcall),PTR2NUM(rb_dl_callback_float_17_0_stdcall),PTR2NUM(rb_dl_callback_float_18_0_stdcall),PTR2NUM(rb_dl_callback_float_19_0_stdcall),PTR2NUM(rb_dl_callback_float_0_1_stdcall),PTR2NUM(rb_dl_callback_float_1_1_stdcall),PTR2NUM(rb_dl_callback_float_2_1_stdcall),PTR2NUM(rb_dl_callback_float_3_1_stdcall),PTR2NUM(rb_dl_callback_float_4_1_stdcall),PTR2NUM(rb_dl_callback_float_5_1_stdcall),PTR2NUM(rb_dl_callback_float_6_1_stdcall),PTR2NUM(rb_dl_callback_float_7_1_stdcall),PTR2NUM(rb_dl_callback_float_8_1_stdcall),PTR2NUM(rb_dl_callback_float_9_1_stdcall),PTR2NUM(rb_dl_callback_float_10_1_stdcall),PTR2NUM(rb_dl_callback_float_11_1_stdcall),PTR2NUM(rb_dl_callback_float_12_1_stdcall),PTR2NUM(rb_dl_callback_float_13_1_stdcall),PTR2NUM(rb_dl_callback_float_14_1_stdcall),PTR2NUM(rb_dl_callback_float_15_1_stdcall),PTR2NUM(rb_dl_callback_float_16_1_stdcall),PTR2NUM(rb_dl_callback_float_17_1_stdcall),PTR2NUM(rb_dl_callback_float_18_1_stdcall),PTR2NUM(rb_dl_callback_float_19_1_stdcall),PTR2NUM(rb_dl_callback_float_0_2_stdcall),PTR2NUM(rb_dl_callback_float_1_2_stdcall),PTR2NUM(rb_dl_callback_float_2_2_stdcall),PTR2NUM(rb_dl_callback_float_3_2_stdcall),PTR2NUM(rb_dl_callback_float_4_2_stdcall),PTR2NUM(rb_dl_callback_float_5_2_stdcall),PTR2NUM(rb_dl_callback_float_6_2_stdcall),PTR2NUM(rb_dl_callback_float_7_2_stdcall),PTR2NUM(rb_dl_callback_float_8_2_stdcall),PTR2NUM(rb_dl_callback_float_9_2_stdcall),PTR2NUM(rb_dl_callback_float_10_2_stdcall),PTR2NUM(rb_dl_callback_float_11_2_stdcall),PTR2NUM(rb_dl_callback_float_12_2_stdcall),PTR2NUM(rb_dl_callback_float_13_2_stdcall),PTR2NUM(rb_dl_callback_float_14_2_stdcall),PTR2NUM(rb_dl_callback_float_15_2_stdcall),PTR2NUM(rb_dl_callback_float_16_2_stdcall),PTR2NUM(rb_dl_callback_float_17_2_stdcall),PTR2NUM(rb_dl_callback_float_18_2_stdcall),PTR2NUM(rb_dl_callback_float_19_2_stdcall),PTR2NUM(rb_dl_callback_float_0_3_stdcall),PTR2NUM(rb_dl_callback_float_1_3_stdcall),PTR2NUM(rb_dl_callback_float_2_3_stdcall),PTR2NUM(rb_dl_callback_float_3_3_stdcall),PTR2NUM(rb_dl_callback_float_4_3_stdcall),PTR2NUM(rb_dl_callback_float_5_3_stdcall),PTR2NUM(rb_dl_callback_float_6_3_stdcall),PTR2NUM(rb_dl_callback_float_7_3_stdcall),PTR2NUM(rb_dl_callback_float_8_3_stdcall),PTR2NUM(rb_dl_callback_float_9_3_stdcall),PTR2NUM(rb_dl_callback_float_10_3_stdcall),PTR2NUM(rb_dl_callback_float_11_3_stdcall),PTR2NUM(rb_dl_callback_float_12_3_stdcall),PTR2NUM(rb_dl_callback_float_13_3_stdcall),PTR2NUM(rb_dl_callback_float_14_3_stdcall),PTR2NUM(rb_dl_callback_float_15_3_stdcall),PTR2NUM(rb_dl_callback_float_16_3_stdcall),PTR2NUM(rb_dl_callback_float_17_3_stdcall),PTR2NUM(rb_dl_callback_float_18_3_stdcall),PTR2NUM(rb_dl_callback_float_19_3_stdcall),PTR2NUM(rb_dl_callback_float_0_4_stdcall),PTR2NUM(rb_dl_callback_float_1_4_stdcall),PTR2NUM(rb_dl_callback_float_2_4_stdcall),PTR2NUM(rb_dl_callback_float_3_4_stdcall),PTR2NUM(rb_dl_callback_float_4_4_stdcall),PTR2NUM(rb_dl_callback_float_5_4_stdcall),PTR2NUM(rb_dl_callback_float_6_4_stdcall),PTR2NUM(rb_dl_callback_float_7_4_stdcall),PTR2NUM(rb_dl_callback_float_8_4_stdcall),PTR2NUM(rb_dl_callback_float_9_4_stdcall),PTR2NUM(rb_dl_callback_float_10_4_stdcall),PTR2NUM(rb_dl_callback_float_11_4_stdcall),PTR2NUM(rb_dl_callback_float_12_4_stdcall),PTR2NUM(rb_dl_callback_float_13_4_stdcall),PTR2NUM(rb_dl_callback_float_14_4_stdcall),PTR2NUM(rb_dl_callback_float_15_4_stdcall),PTR2NUM(rb_dl_callback_float_16_4_stdcall),PTR2NUM(rb_dl_callback_float_17_4_stdcall),PTR2NUM(rb_dl_callback_float_18_4_stdcall),PTR2NUM(rb_dl_callback_float_19_4_stdcall)));
+}
--- /dev/null
+#include "dl.h"
+extern VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+extern VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+extern ID rb_dl_cb_call;
+
+static double
+FUNC_CDECL(rb_dl_callback_double_0_0_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_0_1_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_0_2_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_0_3_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_0_4_cdecl)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_1_0_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_1_1_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_1_2_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_1_3_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_1_4_cdecl)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_2_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_2_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_2_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_2_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_2_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_3_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_3_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_3_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_3_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_3_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_4_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_4_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_4_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_4_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_4_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_5_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_5_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_5_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_5_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_5_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_6_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_6_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_6_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_6_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_6_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_7_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_7_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_7_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_7_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_7_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_8_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_8_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_8_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_8_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_8_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_9_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_9_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_9_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_9_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_9_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_10_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_10_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_10_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_10_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_10_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_11_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_11_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_11_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_11_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_11_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_12_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_12_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_12_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_12_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_12_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_13_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_13_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_13_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_13_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_13_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_14_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_14_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_14_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_14_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_14_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_15_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_15_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_15_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_15_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_15_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_16_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_16_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_16_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_16_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_16_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_17_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_17_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_17_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_17_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_17_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_18_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_18_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_18_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_18_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_18_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_19_0_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_19_1_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_19_2_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_19_3_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_CDECL(rb_dl_callback_double_19_4_cdecl)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLCdeclCallbackProcs, 8), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_0_0_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 0);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_0_1_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 20);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_0_2_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 40);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_0_3_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 60);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_0_4_stdcall)()
+{
+ VALUE ret, cb;
+
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 80);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 0, NULL);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_1_0_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 1);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_1_1_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 21);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_1_2_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 41);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_1_3_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 61);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_1_4_stdcall)(DLSTACK_TYPE stack0)
+{
+ VALUE ret, cb, args[1];
+ args[0] = LONG2NUM(stack0);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 81);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 1, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_2_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 2);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_2_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 22);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_2_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 42);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_2_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 62);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_2_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1)
+{
+ VALUE ret, cb, args[2];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 82);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 2, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_3_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 3);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_3_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 23);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_3_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 43);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_3_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 63);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_3_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2)
+{
+ VALUE ret, cb, args[3];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 83);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 3, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_4_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 4);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_4_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 24);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_4_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 44);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_4_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 64);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_4_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3)
+{
+ VALUE ret, cb, args[4];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 84);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 4, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_5_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 5);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_5_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 25);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_5_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 45);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_5_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 65);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_5_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4)
+{
+ VALUE ret, cb, args[5];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 85);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 5, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_6_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 6);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_6_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 26);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_6_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 46);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_6_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 66);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_6_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5)
+{
+ VALUE ret, cb, args[6];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 86);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 6, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_7_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 7);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_7_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 27);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_7_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 47);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_7_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 67);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_7_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6)
+{
+ VALUE ret, cb, args[7];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 87);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 7, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_8_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 8);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_8_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 28);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_8_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 48);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_8_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 68);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_8_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7)
+{
+ VALUE ret, cb, args[8];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 88);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 8, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_9_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 9);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_9_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 29);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_9_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 49);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_9_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 69);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_9_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8)
+{
+ VALUE ret, cb, args[9];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 89);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 9, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_10_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 10);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_10_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 30);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_10_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 50);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_10_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 70);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_10_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9)
+{
+ VALUE ret, cb, args[10];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 90);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 10, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_11_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 11);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_11_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 31);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_11_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 51);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_11_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 71);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_11_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10)
+{
+ VALUE ret, cb, args[11];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 91);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 11, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_12_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 12);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_12_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 32);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_12_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 52);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_12_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 72);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_12_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11)
+{
+ VALUE ret, cb, args[12];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 92);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 12, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_13_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 13);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_13_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 33);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_13_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 53);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_13_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 73);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_13_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12)
+{
+ VALUE ret, cb, args[13];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 93);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 13, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_14_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 14);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_14_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 34);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_14_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 54);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_14_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 74);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_14_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13)
+{
+ VALUE ret, cb, args[14];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 94);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 14, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_15_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 15);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_15_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 35);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_15_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 55);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_15_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 75);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_15_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14)
+{
+ VALUE ret, cb, args[15];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 95);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 15, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_16_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 16);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_16_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 36);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_16_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 56);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_16_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 76);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_16_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15)
+{
+ VALUE ret, cb, args[16];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 96);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 16, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_17_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 17);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_17_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 37);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_17_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 57);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_17_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 77);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_17_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16)
+{
+ VALUE ret, cb, args[17];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 97);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 17, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_18_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 18);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_18_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 38);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_18_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 58);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_18_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 78);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_18_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17)
+{
+ VALUE ret, cb, args[18];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 98);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 18, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_19_0_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 19);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_19_1_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 39);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_19_2_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 59);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_19_3_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 79);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+
+static double
+FUNC_STDCALL(rb_dl_callback_double_19_4_stdcall)(DLSTACK_TYPE stack0, DLSTACK_TYPE stack1, DLSTACK_TYPE stack2, DLSTACK_TYPE stack3, DLSTACK_TYPE stack4, DLSTACK_TYPE stack5, DLSTACK_TYPE stack6, DLSTACK_TYPE stack7, DLSTACK_TYPE stack8, DLSTACK_TYPE stack9, DLSTACK_TYPE stack10, DLSTACK_TYPE stack11, DLSTACK_TYPE stack12, DLSTACK_TYPE stack13, DLSTACK_TYPE stack14, DLSTACK_TYPE stack15, DLSTACK_TYPE stack16, DLSTACK_TYPE stack17, DLSTACK_TYPE stack18)
+{
+ VALUE ret, cb, args[19];
+ args[0] = LONG2NUM(stack0);
+ args[1] = LONG2NUM(stack1);
+ args[2] = LONG2NUM(stack2);
+ args[3] = LONG2NUM(stack3);
+ args[4] = LONG2NUM(stack4);
+ args[5] = LONG2NUM(stack5);
+ args[6] = LONG2NUM(stack6);
+ args[7] = LONG2NUM(stack7);
+ args[8] = LONG2NUM(stack8);
+ args[9] = LONG2NUM(stack9);
+ args[10] = LONG2NUM(stack10);
+ args[11] = LONG2NUM(stack11);
+ args[12] = LONG2NUM(stack12);
+ args[13] = LONG2NUM(stack13);
+ args[14] = LONG2NUM(stack14);
+ args[15] = LONG2NUM(stack15);
+ args[16] = LONG2NUM(stack16);
+ args[17] = LONG2NUM(stack17);
+ args[18] = LONG2NUM(stack18);
+ cb = rb_ary_entry(rb_ary_entry(rb_DLStdcallCallbackProcs, 8), 99);
+ ret = rb_funcall2(cb, rb_dl_cb_call, 19, args);
+ return RFLOAT_VALUE(ret);
+}
+
+void
+rb_dl_init_callbacks_8()
+{
+ rb_ary_push(rb_DLCdeclCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLCdeclCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_double_0_0_cdecl),PTR2NUM(rb_dl_callback_double_1_0_cdecl),PTR2NUM(rb_dl_callback_double_2_0_cdecl),PTR2NUM(rb_dl_callback_double_3_0_cdecl),PTR2NUM(rb_dl_callback_double_4_0_cdecl),PTR2NUM(rb_dl_callback_double_5_0_cdecl),PTR2NUM(rb_dl_callback_double_6_0_cdecl),PTR2NUM(rb_dl_callback_double_7_0_cdecl),PTR2NUM(rb_dl_callback_double_8_0_cdecl),PTR2NUM(rb_dl_callback_double_9_0_cdecl),PTR2NUM(rb_dl_callback_double_10_0_cdecl),PTR2NUM(rb_dl_callback_double_11_0_cdecl),PTR2NUM(rb_dl_callback_double_12_0_cdecl),PTR2NUM(rb_dl_callback_double_13_0_cdecl),PTR2NUM(rb_dl_callback_double_14_0_cdecl),PTR2NUM(rb_dl_callback_double_15_0_cdecl),PTR2NUM(rb_dl_callback_double_16_0_cdecl),PTR2NUM(rb_dl_callback_double_17_0_cdecl),PTR2NUM(rb_dl_callback_double_18_0_cdecl),PTR2NUM(rb_dl_callback_double_19_0_cdecl),PTR2NUM(rb_dl_callback_double_0_1_cdecl),PTR2NUM(rb_dl_callback_double_1_1_cdecl),PTR2NUM(rb_dl_callback_double_2_1_cdecl),PTR2NUM(rb_dl_callback_double_3_1_cdecl),PTR2NUM(rb_dl_callback_double_4_1_cdecl),PTR2NUM(rb_dl_callback_double_5_1_cdecl),PTR2NUM(rb_dl_callback_double_6_1_cdecl),PTR2NUM(rb_dl_callback_double_7_1_cdecl),PTR2NUM(rb_dl_callback_double_8_1_cdecl),PTR2NUM(rb_dl_callback_double_9_1_cdecl),PTR2NUM(rb_dl_callback_double_10_1_cdecl),PTR2NUM(rb_dl_callback_double_11_1_cdecl),PTR2NUM(rb_dl_callback_double_12_1_cdecl),PTR2NUM(rb_dl_callback_double_13_1_cdecl),PTR2NUM(rb_dl_callback_double_14_1_cdecl),PTR2NUM(rb_dl_callback_double_15_1_cdecl),PTR2NUM(rb_dl_callback_double_16_1_cdecl),PTR2NUM(rb_dl_callback_double_17_1_cdecl),PTR2NUM(rb_dl_callback_double_18_1_cdecl),PTR2NUM(rb_dl_callback_double_19_1_cdecl),PTR2NUM(rb_dl_callback_double_0_2_cdecl),PTR2NUM(rb_dl_callback_double_1_2_cdecl),PTR2NUM(rb_dl_callback_double_2_2_cdecl),PTR2NUM(rb_dl_callback_double_3_2_cdecl),PTR2NUM(rb_dl_callback_double_4_2_cdecl),PTR2NUM(rb_dl_callback_double_5_2_cdecl),PTR2NUM(rb_dl_callback_double_6_2_cdecl),PTR2NUM(rb_dl_callback_double_7_2_cdecl),PTR2NUM(rb_dl_callback_double_8_2_cdecl),PTR2NUM(rb_dl_callback_double_9_2_cdecl),PTR2NUM(rb_dl_callback_double_10_2_cdecl),PTR2NUM(rb_dl_callback_double_11_2_cdecl),PTR2NUM(rb_dl_callback_double_12_2_cdecl),PTR2NUM(rb_dl_callback_double_13_2_cdecl),PTR2NUM(rb_dl_callback_double_14_2_cdecl),PTR2NUM(rb_dl_callback_double_15_2_cdecl),PTR2NUM(rb_dl_callback_double_16_2_cdecl),PTR2NUM(rb_dl_callback_double_17_2_cdecl),PTR2NUM(rb_dl_callback_double_18_2_cdecl),PTR2NUM(rb_dl_callback_double_19_2_cdecl),PTR2NUM(rb_dl_callback_double_0_3_cdecl),PTR2NUM(rb_dl_callback_double_1_3_cdecl),PTR2NUM(rb_dl_callback_double_2_3_cdecl),PTR2NUM(rb_dl_callback_double_3_3_cdecl),PTR2NUM(rb_dl_callback_double_4_3_cdecl),PTR2NUM(rb_dl_callback_double_5_3_cdecl),PTR2NUM(rb_dl_callback_double_6_3_cdecl),PTR2NUM(rb_dl_callback_double_7_3_cdecl),PTR2NUM(rb_dl_callback_double_8_3_cdecl),PTR2NUM(rb_dl_callback_double_9_3_cdecl),PTR2NUM(rb_dl_callback_double_10_3_cdecl),PTR2NUM(rb_dl_callback_double_11_3_cdecl),PTR2NUM(rb_dl_callback_double_12_3_cdecl),PTR2NUM(rb_dl_callback_double_13_3_cdecl),PTR2NUM(rb_dl_callback_double_14_3_cdecl),PTR2NUM(rb_dl_callback_double_15_3_cdecl),PTR2NUM(rb_dl_callback_double_16_3_cdecl),PTR2NUM(rb_dl_callback_double_17_3_cdecl),PTR2NUM(rb_dl_callback_double_18_3_cdecl),PTR2NUM(rb_dl_callback_double_19_3_cdecl),PTR2NUM(rb_dl_callback_double_0_4_cdecl),PTR2NUM(rb_dl_callback_double_1_4_cdecl),PTR2NUM(rb_dl_callback_double_2_4_cdecl),PTR2NUM(rb_dl_callback_double_3_4_cdecl),PTR2NUM(rb_dl_callback_double_4_4_cdecl),PTR2NUM(rb_dl_callback_double_5_4_cdecl),PTR2NUM(rb_dl_callback_double_6_4_cdecl),PTR2NUM(rb_dl_callback_double_7_4_cdecl),PTR2NUM(rb_dl_callback_double_8_4_cdecl),PTR2NUM(rb_dl_callback_double_9_4_cdecl),PTR2NUM(rb_dl_callback_double_10_4_cdecl),PTR2NUM(rb_dl_callback_double_11_4_cdecl),PTR2NUM(rb_dl_callback_double_12_4_cdecl),PTR2NUM(rb_dl_callback_double_13_4_cdecl),PTR2NUM(rb_dl_callback_double_14_4_cdecl),PTR2NUM(rb_dl_callback_double_15_4_cdecl),PTR2NUM(rb_dl_callback_double_16_4_cdecl),PTR2NUM(rb_dl_callback_double_17_4_cdecl),PTR2NUM(rb_dl_callback_double_18_4_cdecl),PTR2NUM(rb_dl_callback_double_19_4_cdecl)));
+ rb_ary_push(rb_DLStdcallCallbackProcs, rb_ary_new3(100,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil,Qnil));
+ rb_ary_push(rb_DLStdcallCallbackAddrs, rb_ary_new3(100,PTR2NUM(rb_dl_callback_double_0_0_stdcall),PTR2NUM(rb_dl_callback_double_1_0_stdcall),PTR2NUM(rb_dl_callback_double_2_0_stdcall),PTR2NUM(rb_dl_callback_double_3_0_stdcall),PTR2NUM(rb_dl_callback_double_4_0_stdcall),PTR2NUM(rb_dl_callback_double_5_0_stdcall),PTR2NUM(rb_dl_callback_double_6_0_stdcall),PTR2NUM(rb_dl_callback_double_7_0_stdcall),PTR2NUM(rb_dl_callback_double_8_0_stdcall),PTR2NUM(rb_dl_callback_double_9_0_stdcall),PTR2NUM(rb_dl_callback_double_10_0_stdcall),PTR2NUM(rb_dl_callback_double_11_0_stdcall),PTR2NUM(rb_dl_callback_double_12_0_stdcall),PTR2NUM(rb_dl_callback_double_13_0_stdcall),PTR2NUM(rb_dl_callback_double_14_0_stdcall),PTR2NUM(rb_dl_callback_double_15_0_stdcall),PTR2NUM(rb_dl_callback_double_16_0_stdcall),PTR2NUM(rb_dl_callback_double_17_0_stdcall),PTR2NUM(rb_dl_callback_double_18_0_stdcall),PTR2NUM(rb_dl_callback_double_19_0_stdcall),PTR2NUM(rb_dl_callback_double_0_1_stdcall),PTR2NUM(rb_dl_callback_double_1_1_stdcall),PTR2NUM(rb_dl_callback_double_2_1_stdcall),PTR2NUM(rb_dl_callback_double_3_1_stdcall),PTR2NUM(rb_dl_callback_double_4_1_stdcall),PTR2NUM(rb_dl_callback_double_5_1_stdcall),PTR2NUM(rb_dl_callback_double_6_1_stdcall),PTR2NUM(rb_dl_callback_double_7_1_stdcall),PTR2NUM(rb_dl_callback_double_8_1_stdcall),PTR2NUM(rb_dl_callback_double_9_1_stdcall),PTR2NUM(rb_dl_callback_double_10_1_stdcall),PTR2NUM(rb_dl_callback_double_11_1_stdcall),PTR2NUM(rb_dl_callback_double_12_1_stdcall),PTR2NUM(rb_dl_callback_double_13_1_stdcall),PTR2NUM(rb_dl_callback_double_14_1_stdcall),PTR2NUM(rb_dl_callback_double_15_1_stdcall),PTR2NUM(rb_dl_callback_double_16_1_stdcall),PTR2NUM(rb_dl_callback_double_17_1_stdcall),PTR2NUM(rb_dl_callback_double_18_1_stdcall),PTR2NUM(rb_dl_callback_double_19_1_stdcall),PTR2NUM(rb_dl_callback_double_0_2_stdcall),PTR2NUM(rb_dl_callback_double_1_2_stdcall),PTR2NUM(rb_dl_callback_double_2_2_stdcall),PTR2NUM(rb_dl_callback_double_3_2_stdcall),PTR2NUM(rb_dl_callback_double_4_2_stdcall),PTR2NUM(rb_dl_callback_double_5_2_stdcall),PTR2NUM(rb_dl_callback_double_6_2_stdcall),PTR2NUM(rb_dl_callback_double_7_2_stdcall),PTR2NUM(rb_dl_callback_double_8_2_stdcall),PTR2NUM(rb_dl_callback_double_9_2_stdcall),PTR2NUM(rb_dl_callback_double_10_2_stdcall),PTR2NUM(rb_dl_callback_double_11_2_stdcall),PTR2NUM(rb_dl_callback_double_12_2_stdcall),PTR2NUM(rb_dl_callback_double_13_2_stdcall),PTR2NUM(rb_dl_callback_double_14_2_stdcall),PTR2NUM(rb_dl_callback_double_15_2_stdcall),PTR2NUM(rb_dl_callback_double_16_2_stdcall),PTR2NUM(rb_dl_callback_double_17_2_stdcall),PTR2NUM(rb_dl_callback_double_18_2_stdcall),PTR2NUM(rb_dl_callback_double_19_2_stdcall),PTR2NUM(rb_dl_callback_double_0_3_stdcall),PTR2NUM(rb_dl_callback_double_1_3_stdcall),PTR2NUM(rb_dl_callback_double_2_3_stdcall),PTR2NUM(rb_dl_callback_double_3_3_stdcall),PTR2NUM(rb_dl_callback_double_4_3_stdcall),PTR2NUM(rb_dl_callback_double_5_3_stdcall),PTR2NUM(rb_dl_callback_double_6_3_stdcall),PTR2NUM(rb_dl_callback_double_7_3_stdcall),PTR2NUM(rb_dl_callback_double_8_3_stdcall),PTR2NUM(rb_dl_callback_double_9_3_stdcall),PTR2NUM(rb_dl_callback_double_10_3_stdcall),PTR2NUM(rb_dl_callback_double_11_3_stdcall),PTR2NUM(rb_dl_callback_double_12_3_stdcall),PTR2NUM(rb_dl_callback_double_13_3_stdcall),PTR2NUM(rb_dl_callback_double_14_3_stdcall),PTR2NUM(rb_dl_callback_double_15_3_stdcall),PTR2NUM(rb_dl_callback_double_16_3_stdcall),PTR2NUM(rb_dl_callback_double_17_3_stdcall),PTR2NUM(rb_dl_callback_double_18_3_stdcall),PTR2NUM(rb_dl_callback_double_19_3_stdcall),PTR2NUM(rb_dl_callback_double_0_4_stdcall),PTR2NUM(rb_dl_callback_double_1_4_stdcall),PTR2NUM(rb_dl_callback_double_2_4_stdcall),PTR2NUM(rb_dl_callback_double_3_4_stdcall),PTR2NUM(rb_dl_callback_double_4_4_stdcall),PTR2NUM(rb_dl_callback_double_5_4_stdcall),PTR2NUM(rb_dl_callback_double_6_4_stdcall),PTR2NUM(rb_dl_callback_double_7_4_stdcall),PTR2NUM(rb_dl_callback_double_8_4_stdcall),PTR2NUM(rb_dl_callback_double_9_4_stdcall),PTR2NUM(rb_dl_callback_double_10_4_stdcall),PTR2NUM(rb_dl_callback_double_11_4_stdcall),PTR2NUM(rb_dl_callback_double_12_4_stdcall),PTR2NUM(rb_dl_callback_double_13_4_stdcall),PTR2NUM(rb_dl_callback_double_14_4_stdcall),PTR2NUM(rb_dl_callback_double_15_4_stdcall),PTR2NUM(rb_dl_callback_double_16_4_stdcall),PTR2NUM(rb_dl_callback_double_17_4_stdcall),PTR2NUM(rb_dl_callback_double_18_4_stdcall),PTR2NUM(rb_dl_callback_double_19_4_stdcall)));
+}
--- /dev/null
+VALUE rb_DLCdeclCallbackAddrs, rb_DLCdeclCallbackProcs;
+VALUE rb_DLStdcallCallbackAddrs, rb_DLStdcallCallbackProcs;
+/*static void *cdecl_callbacks[MAX_DLTYPE][MAX_CALLBACK];*/
+/*static void *stdcall_callbacks[MAX_DLTYPE][MAX_CALLBACK];*/
+ID rb_dl_cb_call;
+void rb_dl_init_callbacks_0();
+void rb_dl_init_callbacks_1();
+void rb_dl_init_callbacks_2();
+void rb_dl_init_callbacks_3();
+void rb_dl_init_callbacks_4();
+void rb_dl_init_callbacks_5();
+void rb_dl_init_callbacks_6();
+void rb_dl_init_callbacks_7();
+void rb_dl_init_callbacks_8();
+static void
+rb_dl_init_callbacks()
+{
+ VALUE tmp;
+ rb_dl_cb_call = rb_intern("call");
+
+ tmp = rb_DLCdeclCallbackProcs = rb_ary_new();
+ rb_define_const(rb_mDL, "CdeclCallbackProcs", tmp);
+
+ tmp = rb_DLCdeclCallbackAddrs = rb_ary_new();
+ rb_define_const(rb_mDL, "CdeclCallbackAddrs", tmp);
+
+ tmp = rb_DLStdcallCallbackProcs = rb_ary_new();
+ rb_define_const(rb_mDL, "StdcallCallbackProcs", tmp);
+
+ tmp = rb_DLStdcallCallbackAddrs = rb_ary_new();
+ rb_define_const(rb_mDL, "StdcallCallbackAddrs", tmp);
+
+ rb_dl_init_callbacks_0();
+ rb_dl_init_callbacks_1();
+ rb_dl_init_callbacks_2();
+ rb_dl_init_callbacks_3();
+ rb_dl_init_callbacks_4();
+ rb_dl_init_callbacks_5();
+ rb_dl_init_callbacks_6();
+ rb_dl_init_callbacks_7();
+ rb_dl_init_callbacks_8();
+
+}
--- /dev/null
+#include "ruby.h"
+
+#define init(func, name) { \
+ extern void func _((void)); \
+ ruby_init_ext(name, func); \
+}
+
+void ruby_init_ext _((const char *name, void (*init)(void)));
+
+void Init_ext _((void))
+{
+ init(Init_bigdecimal, "bigdecimal.so");
+ init(Init_continuation, "continuation.so");
+ init(Init_coverage, "coverage.so");
+ init(Init_digest, "digest.so");
+ init(Init_bubblebabble, "digest/bubblebabble.so");
+ init(Init_md5, "digest/md5.so");
+ init(Init_rmd160, "digest/rmd160.so");
+ init(Init_sha1, "digest/sha1.so");
+ init(Init_sha2, "digest/sha2.so");
+ init(Init_dl, "dl.so");
+ init(Init_etc, "etc.so");
+ init(Init_fcntl, "fcntl.so");
+ init(Init_fiber, "fiber.so");
+ init(Init_wait, "io/wait.so");
+ //init(Init_generator, "json/ext/generator.so");
+ //init(Init_parser, "json/ext/parser.so");
+ //init(Init_complex, "mathn/complex.so");
+ //init(Init_rational, "mathn/rational.so");
+ init(Init_nkf, "nkf.so");
+ init(Init_openssl, "openssl.so");
+ init(Init_pty, "pty.so");
+ init(Init_cparse, "racc/cparse.so");
+ init(Init_ripper, "ripper.so");
+ init(Init_sdbm, "sdbm.so");
+ init(Init_socket, "socket.so");
+ init(Init_stringio, "stringio.so");
+ init(Init_strscan, "strscan.so");
+ init(Init_syck, "syck.so");
+ init(Init_syslog, "syslog.so");
+ init(Init_zlib, "zlib.so");
+}
--- /dev/null
+#include "unicode.h"
+
+#define unicode_escape(buffer, character) \
+ snprintf(buf, 7, "\\u%04x", (unsigned int) (character)); \
+ rb_str_buf_cat(buffer, buf, 6);
+
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ *
+ * Disclaimer
+ *
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ *
+ * Limitations on Rights to Redistribute This Code
+ *
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/*
+ * Index into the table below with the first byte of a UTF-8 sequence to
+ * get the number of trailing bytes that are supposed to follow it.
+ * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
+ * left as-is for anyone who may want to do such conversion, which was
+ * allowed in earlier algorithms.
+ */
+static const char trailingBytesForUTF8[256] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+ 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/*
+ * Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence.
+ */
+static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
+ 0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+
+/*
+ * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
+ * into the first byte, depending on how many bytes follow. There are
+ * as many entries in this table as there are UTF-8 sequence types.
+ * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
+ * for *legal* UTF-8 will be 4 or fewer bytes total.
+ */
+static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+/*
+ * Utility routine to tell whether a sequence of bytes is legal UTF-8.
+ * This must be called with the length pre-determined by the first byte.
+ * If not calling this from ConvertUTF8to*, then the length can be set by:
+ * length = trailingBytesForUTF8[*source]+1;
+ * and the sequence is illegal right away if there aren't that many bytes
+ * available.
+ * If presented with a length > 4, this returns 0. The Unicode
+ * definition of UTF-8 goes up to 4-byte sequences.
+ */
+
+inline static unsigned char isLegalUTF8(const UTF8 *source, int length)
+{
+ UTF8 a;
+ const UTF8 *srcptr = source+length;
+ switch (length) {
+ default: return 0;
+ /* Everything else falls through when "1"... */
+ case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+ case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+ case 2: if ((a = (*--srcptr)) > 0xBF) return 0;
+
+ switch (*source) {
+ /* no fall-through in this inner switch */
+ case 0xE0: if (a < 0xA0) return 0; break;
+ case 0xED: if (a > 0x9F) return 0; break;
+ case 0xF0: if (a < 0x90) return 0; break;
+ case 0xF4: if (a > 0x8F) return 0; break;
+ default: if (a < 0x80) return 0;
+ }
+
+ case 1: if (*source >= 0x80 && *source < 0xC2) return 0;
+ }
+ if (*source > 0xF4) return 0;
+ return 1;
+}
+
+void JSON_convert_UTF8_to_JSON(VALUE buffer, VALUE string, ConversionFlags flags)
+{
+ char buf[7];
+ const UTF8* source = (UTF8 *) RSTRING_PTR(string);
+ const UTF8* sourceEnd = source + RSTRING_LEN(string);
+
+ while (source < sourceEnd) {
+ UTF32 ch = 0;
+ unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
+ if (source + extraBytesToRead >= sourceEnd) {
+ rb_raise(rb_path2class("JSON::GeneratorError"),
+ "partial character in source, but hit end");
+ }
+ if (!isLegalUTF8(source, extraBytesToRead+1)) {
+ rb_raise(rb_path2class("JSON::GeneratorError"),
+ "source sequence is illegal/malformed");
+ }
+ /*
+ * The cases all fall through. See "Note A" below.
+ */
+ switch (extraBytesToRead) {
+ case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
+ case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
+ case 3: ch += *source++; ch <<= 6;
+ case 2: ch += *source++; ch <<= 6;
+ case 1: ch += *source++; ch <<= 6;
+ case 0: ch += *source++;
+ }
+ ch -= offsetsFromUTF8[extraBytesToRead];
+
+ if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
+ /* UTF-16 surrogate values are illegal in UTF-32 */
+ if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+ if (flags == strictConversion) {
+ source -= (extraBytesToRead+1); /* return to the illegal value itself */
+ rb_raise(rb_path2class("JSON::GeneratorError"),
+ "source sequence is illegal/malformed");
+ } else {
+ unicode_escape(buffer, UNI_REPLACEMENT_CHAR);
+ }
+ } else {
+ /* normal case */
+ if (ch == '"') {
+ rb_str_buf_cat2(buffer, "\\\"");
+ } else if (ch == '\\') {
+ rb_str_buf_cat2(buffer, "\\\\");
+ } else if (ch == '/') {
+ rb_str_buf_cat2(buffer, "\\/");
+ } else if (ch >= 0x20 && ch <= 0x7f) {
+ rb_str_buf_cat(buffer, (char *) source - 1, 1);
+ } else if (ch == '\n') {
+ rb_str_buf_cat2(buffer, "\\n");
+ } else if (ch == '\r') {
+ rb_str_buf_cat2(buffer, "\\r");
+ } else if (ch == '\t') {
+ rb_str_buf_cat2(buffer, "\\t");
+ } else if (ch == '\f') {
+ rb_str_buf_cat2(buffer, "\\f");
+ } else if (ch == '\b') {
+ rb_str_buf_cat2(buffer, "\\b");
+ } else if (ch < 0x20) {
+ unicode_escape(buffer, (UTF16) ch);
+ } else {
+ unicode_escape(buffer, (UTF16) ch);
+ }
+ }
+ } else if (ch > UNI_MAX_UTF16) {
+ if (flags == strictConversion) {
+ source -= (extraBytesToRead+1); /* return to the start */
+ rb_raise(rb_path2class("JSON::GeneratorError"),
+ "source sequence is illegal/malformed");
+ } else {
+ unicode_escape(buffer, UNI_REPLACEMENT_CHAR);
+ }
+ } else {
+ /* target is a character in range 0xFFFF - 0x10FFFF. */
+ ch -= halfBase;
+ unicode_escape(buffer, (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START));
+ unicode_escape(buffer, (UTF16)((ch & halfMask) + UNI_SUR_LOW_START));
+ }
+ }
+}
--- /dev/null
+#include "unicode.h"
+
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ *
+ * Disclaimer
+ *
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ *
+ * Limitations on Rights to Redistribute This Code
+ *
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/*
+ * Index into the table below with the first byte of a UTF-8 sequence to
+ * get the number of trailing bytes that are supposed to follow it.
+ * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
+ * left as-is for anyone who may want to do such conversion, which was
+ * allowed in earlier algorithms.
+ */
+static const char trailingBytesForUTF8[256] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+ 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/*
+ * Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence.
+ */
+static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL,
+ 0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+
+/*
+ * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
+ * into the first byte, depending on how many bytes follow. There are
+ * as many entries in this table as there are UTF-8 sequence types.
+ * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
+ * for *legal* UTF-8 will be 4 or fewer bytes total.
+ */
+static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+char *JSON_convert_UTF16_to_UTF8 (
+ VALUE buffer,
+ char *source,
+ char *sourceEnd,
+ ConversionFlags flags)
+{
+ UTF16 *tmp, *tmpPtr, *tmpEnd;
+ char buf[5];
+ long n = 0, i;
+ char *p = source - 1;
+
+ while (p < sourceEnd && p[0] == '\\' && p[1] == 'u') {
+ p += 6;
+ n++;
+ }
+ p = source + 1;
+ buf[4] = 0;
+ tmpPtr = tmp = ALLOC_N(UTF16, n);
+ tmpEnd = tmp + n;
+ for (i = 0; i < n; i++) {
+ buf[0] = *p++;
+ buf[1] = *p++;
+ buf[2] = *p++;
+ buf[3] = *p++;
+ tmpPtr[i] = strtol(buf, NULL, 16);
+ p += 2;
+ }
+
+ while (tmpPtr < tmpEnd) {
+ UTF32 ch;
+ unsigned short bytesToWrite = 0;
+ const UTF32 byteMask = 0xBF;
+ const UTF32 byteMark = 0x80;
+ ch = *tmpPtr++;
+ /* If we have a surrogate pair, convert to UTF32 first. */
+ if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
+ /* If the 16 bits following the high surrogate are in the source
+ * buffer... */
+ if (tmpPtr < tmpEnd) {
+ UTF32 ch2 = *tmpPtr;
+ /* If it's a low surrogate, convert to UTF32. */
+ if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
+ ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
+ + (ch2 - UNI_SUR_LOW_START) + halfBase;
+ ++tmpPtr;
+ } else if (flags == strictConversion) { /* it's an unpaired high surrogate */
+ ruby_xfree(tmp);
+ rb_raise(rb_path2class("JSON::ParserError"),
+ "source sequence is illegal/malformed near %s", source);
+ }
+ } else { /* We don't have the 16 bits following the high surrogate. */
+ ruby_xfree(tmp);
+ rb_raise(rb_path2class("JSON::ParserError"),
+ "partial character in source, but hit end near %s", source);
+ break;
+ }
+ } else if (flags == strictConversion) {
+ /* UTF-16 surrogate values are illegal in UTF-32 */
+ if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
+ ruby_xfree(tmp);
+ rb_raise(rb_path2class("JSON::ParserError"),
+ "source sequence is illegal/malformed near %s", source);
+ }
+ }
+ /* Figure out how many bytes the result will require */
+ if (ch < (UTF32) 0x80) {
+ bytesToWrite = 1;
+ } else if (ch < (UTF32) 0x800) {
+ bytesToWrite = 2;
+ } else if (ch < (UTF32) 0x10000) {
+ bytesToWrite = 3;
+ } else if (ch < (UTF32) 0x110000) {
+ bytesToWrite = 4;
+ } else {
+ bytesToWrite = 3;
+ ch = UNI_REPLACEMENT_CHAR;
+ }
+
+ buf[0] = 0;
+ buf[1] = 0;
+ buf[2] = 0;
+ buf[3] = 0;
+ p = buf + bytesToWrite;
+ switch (bytesToWrite) { /* note: everything falls through. */
+ case 4: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
+ case 3: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
+ case 2: *--p = (UTF8) ((ch | byteMark) & byteMask); ch >>= 6;
+ case 1: *--p = (UTF8) (ch | firstByteMark[bytesToWrite]);
+ }
+ rb_str_buf_cat(buffer, p, bytesToWrite);
+ }
+ ruby_xfree(tmp);
+ source += 5 + (n - 1) * 6;
+ return source;
+}
--- /dev/null
+extern void nucomp_canonicalization(int);
+
+void
+Init_complex(void)
+{
+ nucomp_canonicalization(1);
+}
--- /dev/null
+extern void nurat_canonicalization(int);
+
+void
+Init_rational(void)
+{
+ nurat_canonicalization(1);
+}
# ifndef HAVE_LOCALE_H
# define HAVE_LOCALE_H
# endif
+#elif defined(__BIONIC__)
#else
# ifndef HAVE_LANGINFO_H
# define HAVE_LANGINFO_H
--- /dev/null
+/* crypto/bn/bn_depr.c */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ * software must display the following acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ * endorse or promote products derived from this software without
+ * prior written permission. For written permission, please contact
+ * openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ * nor may "OpenSSL" appear in their names without prior written
+ * permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ * acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com). This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+/* Support for deprecated functions goes here - static linkage will only slurp
+ * this code if applications are using them directly. */
+
+#include <stdio.h>
+#include <time.h>
+//#include "cryptlib.h"
+//#include "bn_lcl.h"
+#include <openssl/bn.h>
+#include <openssl/rand.h>
+
+static void *dummy=&dummy;
+
+#if 1//ndef OPENSSL_NO_DEPRECATED
+BIGNUM *BN_generate_prime(BIGNUM *ret, int bits, int safe,
+ const BIGNUM *add, const BIGNUM *rem,
+ void (*callback)(int,int,void *), void *cb_arg)
+ {
+ BN_GENCB cb;
+ BIGNUM *rnd=NULL;
+ int found = 0;
+
+ BN_GENCB_set_old(&cb, callback, cb_arg);
+
+ if (ret == NULL)
+ {
+ if ((rnd=BN_new()) == NULL) goto err;
+ }
+ else
+ rnd=ret;
+ if(!BN_generate_prime_ex(rnd, bits, safe, add, rem, &cb))
+ goto err;
+
+ /* we have a prime :-) */
+ found = 1;
+err:
+ if (!found && (ret == NULL) && (rnd != NULL)) BN_free(rnd);
+ return(found ? rnd : NULL);
+ }
+
+int BN_is_prime(const BIGNUM *a, int checks, void (*callback)(int,int,void *),
+ BN_CTX *ctx_passed, void *cb_arg)
+ {
+ BN_GENCB cb;
+ BN_GENCB_set_old(&cb, callback, cb_arg);
+ return BN_is_prime_ex(a, checks, ctx_passed, &cb);
+ }
+
+int BN_is_prime_fasttest(const BIGNUM *a, int checks,
+ void (*callback)(int,int,void *),
+ BN_CTX *ctx_passed, void *cb_arg,
+ int do_trial_division)
+ {
+ BN_GENCB cb;
+ BN_GENCB_set_old(&cb, callback, cb_arg);
+ return BN_is_prime_fasttest_ex(a, checks, ctx_passed,
+ do_trial_division, &cb);
+ }
+#endif
--- /dev/null
+/* crypto/rsa/rsa_depr.c */
+/* ====================================================================
+ * Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ * software must display the following acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ * endorse or promote products derived from this software without
+ * prior written permission. For written permission, please contact
+ * openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ * nor may "OpenSSL" appear in their names without prior written
+ * permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ * acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com). This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+/* NB: This file contains deprecated functions (compatibility wrappers to the
+ * "new" versions). */
+
+#include <stdio.h>
+#include <time.h>
+//#include "cryptlib.h"
+#include <openssl/bn.h>
+#include <openssl/rsa.h>
+
+#ifdef OPENSSL_NO_DEPRECATED
+
+static void *dummy=&dummy;
+
+#else
+
+RSA *RSA_generate_key(int bits, unsigned long e_value,
+ void (*callback)(int,int,void *), void *cb_arg)
+ {
+ BN_GENCB cb;
+ int i;
+ RSA *rsa = RSA_new();
+ BIGNUM *e = BN_new();
+
+ if(!rsa || !e) goto err;
+
+ /* The problem is when building with 8, 16, or 32 BN_ULONG,
+ * unsigned long can be larger */
+ for (i=0; i<(int)sizeof(unsigned long)*8; i++)
+ {
+ if (e_value & (1UL<<i))
+ if (BN_set_bit(e,i) == 0)
+ goto err;
+ }
+
+ BN_GENCB_set_old(&cb, callback, cb_arg);
+
+ if(RSA_generate_key_ex(rsa, bits, e, &cb)) {
+ BN_free(e);
+ return rsa;
+ }
+err:
+ if(e) BN_free(e);
+ if(rsa) RSA_free(rsa);
+ return 0;
+ }
+#endif
+#define RIPPER 1
/* A Bison parser, made by GNU Bison 2.3. */
/* Skeleton implementation for Bison's Yacc-like parsers in C
--- /dev/null
+#define pseudo_AF_FTIP pseudo_AF_RTIP
+#ifdef SOCK_STREAM
+ sock_define_const("SOCK_STREAM", SOCK_STREAM);
+#endif
+
+#ifdef SOCK_DGRAM
+ sock_define_const("SOCK_DGRAM", SOCK_DGRAM);
+#endif
+
+#ifdef SOCK_RAW
+ sock_define_const("SOCK_RAW", SOCK_RAW);
+#endif
+
+#ifdef SOCK_RDM
+ sock_define_const("SOCK_RDM", SOCK_RDM);
+#endif
+
+#ifdef SOCK_SEQPACKET
+ sock_define_const("SOCK_SEQPACKET", SOCK_SEQPACKET);
+#endif
+
+#ifdef SOCK_PACKET
+ sock_define_const("SOCK_PACKET", SOCK_PACKET);
+#endif
+
+#ifdef AF_INET
+ sock_define_const("AF_INET", AF_INET);
+#endif
+
+#ifdef PF_INET
+ sock_define_const("PF_INET", PF_INET);
+#endif
+
+#ifdef AF_UNIX
+ sock_define_const("AF_UNIX", AF_UNIX);
+#endif
+
+#ifdef PF_UNIX
+ sock_define_const("PF_UNIX", PF_UNIX);
+#endif
+
+#ifdef AF_AX25
+ sock_define_const("AF_AX25", AF_AX25);
+#endif
+
+#ifdef PF_AX25
+ sock_define_const("PF_AX25", PF_AX25);
+#endif
+
+#ifdef AF_IPX
+ sock_define_const("AF_IPX", AF_IPX);
+#endif
+
+#ifdef PF_IPX
+ sock_define_const("PF_IPX", PF_IPX);
+#endif
+
+#ifdef AF_APPLETALK
+ sock_define_const("AF_APPLETALK", AF_APPLETALK);
+#endif
+
+#ifdef PF_APPLETALK
+ sock_define_const("PF_APPLETALK", PF_APPLETALK);
+#endif
+
+#ifdef AF_UNSPEC
+ sock_define_const("AF_UNSPEC", AF_UNSPEC);
+#endif
+
+#ifdef PF_UNSPEC
+ sock_define_const("PF_UNSPEC", PF_UNSPEC);
+#endif
+
+#ifdef AF_LOCAL
+ sock_define_const("AF_LOCAL", AF_LOCAL);
+#endif
+
+#ifdef PF_LOCAL
+ sock_define_const("PF_LOCAL", PF_LOCAL);
+#endif
+
+#ifdef AF_IMPLINK
+ sock_define_const("AF_IMPLINK", AF_IMPLINK);
+#endif
+
+#ifdef PF_IMPLINK
+ sock_define_const("PF_IMPLINK", PF_IMPLINK);
+#endif
+
+#ifdef AF_PUP
+ sock_define_const("AF_PUP", AF_PUP);
+#endif
+
+#ifdef PF_PUP
+ sock_define_const("PF_PUP", PF_PUP);
+#endif
+
+#ifdef AF_CHAOS
+ sock_define_const("AF_CHAOS", AF_CHAOS);
+#endif
+
+#ifdef PF_CHAOS
+ sock_define_const("PF_CHAOS", PF_CHAOS);
+#endif
+
+#ifdef AF_NS
+ sock_define_const("AF_NS", AF_NS);
+#endif
+
+#ifdef PF_NS
+ sock_define_const("PF_NS", PF_NS);
+#endif
+
+#ifdef AF_ISO
+ sock_define_const("AF_ISO", AF_ISO);
+#endif
+
+#ifdef PF_ISO
+ sock_define_const("PF_ISO", PF_ISO);
+#endif
+
+#ifdef AF_OSI
+ sock_define_const("AF_OSI", AF_OSI);
+#endif
+
+#ifdef PF_OSI
+ sock_define_const("PF_OSI", PF_OSI);
+#endif
+
+#ifdef AF_ECMA
+ sock_define_const("AF_ECMA", AF_ECMA);
+#endif
+
+#ifdef PF_ECMA
+ sock_define_const("PF_ECMA", PF_ECMA);
+#endif
+
+#ifdef AF_DATAKIT
+ sock_define_const("AF_DATAKIT", AF_DATAKIT);
+#endif
+
+#ifdef PF_DATAKIT
+ sock_define_const("PF_DATAKIT", PF_DATAKIT);
+#endif
+
+#ifdef AF_CCITT
+ sock_define_const("AF_CCITT", AF_CCITT);
+#endif
+
+#ifdef PF_CCITT
+ sock_define_const("PF_CCITT", PF_CCITT);
+#endif
+
+#ifdef AF_SNA
+ sock_define_const("AF_SNA", AF_SNA);
+#endif
+
+#ifdef PF_SNA
+ sock_define_const("PF_SNA", PF_SNA);
+#endif
+
+#ifdef AF_DEC
+ sock_define_const("AF_DEC", AF_DEC);
+#endif
+
+#ifdef PF_DEC
+ sock_define_const("PF_DEC", PF_DEC);
+#endif
+
+#ifdef AF_DLI
+ sock_define_const("AF_DLI", AF_DLI);
+#endif
+
+#ifdef PF_DLI
+ sock_define_const("PF_DLI", PF_DLI);
+#endif
+
+#ifdef AF_LAT
+ sock_define_const("AF_LAT", AF_LAT);
+#endif
+
+#ifdef PF_LAT
+ sock_define_const("PF_LAT", PF_LAT);
+#endif
+
+#ifdef AF_HYLINK
+ sock_define_const("AF_HYLINK", AF_HYLINK);
+#endif
+
+#ifdef PF_HYLINK
+ sock_define_const("PF_HYLINK", PF_HYLINK);
+#endif
+
+#ifdef AF_ROUTE
+ sock_define_const("AF_ROUTE", AF_ROUTE);
+#endif
+
+#ifdef PF_ROUTE
+ sock_define_const("PF_ROUTE", PF_ROUTE);
+#endif
+
+#ifdef AF_LINK
+ sock_define_const("AF_LINK", AF_LINK);
+#endif
+
+#ifdef PF_LINK
+ sock_define_const("PF_LINK", PF_LINK);
+#endif
+
+#ifdef AF_COIP
+ sock_define_const("AF_COIP", AF_COIP);
+#endif
+
+#ifdef PF_COIP
+ sock_define_const("PF_COIP", PF_COIP);
+#endif
+
+#ifdef AF_CNT
+ sock_define_const("AF_CNT", AF_CNT);
+#endif
+
+#ifdef PF_CNT
+ sock_define_const("PF_CNT", PF_CNT);
+#endif
+
+#ifdef AF_SIP
+ sock_define_const("AF_SIP", AF_SIP);
+#endif
+
+#ifdef PF_SIP
+ sock_define_const("PF_SIP", PF_SIP);
+#endif
+
+#ifdef AF_NDRV
+ sock_define_const("AF_NDRV", AF_NDRV);
+#endif
+
+#ifdef PF_NDRV
+ sock_define_const("PF_NDRV", PF_NDRV);
+#endif
+
+#ifdef AF_ISDN
+ sock_define_const("AF_ISDN", AF_ISDN);
+#endif
+
+#ifdef PF_ISDN
+ sock_define_const("PF_ISDN", PF_ISDN);
+#endif
+
+#ifdef AF_NATM
+ sock_define_const("AF_NATM", AF_NATM);
+#endif
+
+#ifdef PF_NATM
+ sock_define_const("PF_NATM", PF_NATM);
+#endif
+
+#ifdef AF_SYSTEM
+ sock_define_const("AF_SYSTEM", AF_SYSTEM);
+#endif
+
+#ifdef PF_SYSTEM
+ sock_define_const("PF_SYSTEM", PF_SYSTEM);
+#endif
+
+#ifdef AF_NETBIOS
+ sock_define_const("AF_NETBIOS", AF_NETBIOS);
+#endif
+
+#ifdef PF_NETBIOS
+ sock_define_const("PF_NETBIOS", PF_NETBIOS);
+#endif
+
+#ifdef AF_PPP
+ sock_define_const("AF_PPP", AF_PPP);
+#endif
+
+#ifdef PF_PPP
+ sock_define_const("PF_PPP", PF_PPP);
+#endif
+
+#ifdef AF_ATM
+ sock_define_const("AF_ATM", AF_ATM);
+#endif
+
+#ifdef PF_ATM
+ sock_define_const("PF_ATM", PF_ATM);
+#endif
+
+#ifdef AF_NETGRAPH
+ sock_define_const("AF_NETGRAPH", AF_NETGRAPH);
+#endif
+
+#ifdef PF_NETGRAPH
+ sock_define_const("PF_NETGRAPH", PF_NETGRAPH);
+#endif
+
+#ifdef AF_MAX
+ sock_define_const("AF_MAX", AF_MAX);
+#endif
+
+#ifdef PF_MAX
+ sock_define_const("PF_MAX", PF_MAX);
+#endif
+
+#ifdef AF_E164
+ sock_define_const("AF_E164", AF_E164);
+#endif
+
+#ifdef PF_XTP
+ sock_define_const("PF_XTP", PF_XTP);
+#endif
+
+#ifdef PF_RTIP
+ sock_define_const("PF_RTIP", PF_RTIP);
+#endif
+
+#ifdef PF_PIP
+ sock_define_const("PF_PIP", PF_PIP);
+#endif
+
+#ifdef PF_KEY
+ sock_define_const("PF_KEY", PF_KEY);
+#endif
+
+#ifdef MSG_OOB
+ sock_define_const("MSG_OOB", MSG_OOB);
+#endif
+
+#ifdef MSG_PEEK
+ sock_define_const("MSG_PEEK", MSG_PEEK);
+#endif
+
+#ifdef MSG_DONTROUTE
+ sock_define_const("MSG_DONTROUTE", MSG_DONTROUTE);
+#endif
+
+#ifdef MSG_EOR
+ sock_define_const("MSG_EOR", MSG_EOR);
+#endif
+
+#ifdef MSG_TRUNC
+ sock_define_const("MSG_TRUNC", MSG_TRUNC);
+#endif
+
+#ifdef MSG_CTRUNC
+ sock_define_const("MSG_CTRUNC", MSG_CTRUNC);
+#endif
+
+#ifdef MSG_WAITALL
+ sock_define_const("MSG_WAITALL", MSG_WAITALL);
+#endif
+
+#ifdef MSG_DONTWAIT
+ sock_define_const("MSG_DONTWAIT", MSG_DONTWAIT);
+#endif
+
+#ifdef MSG_EOF
+ sock_define_const("MSG_EOF", MSG_EOF);
+#endif
+
+#ifdef MSG_FLUSH
+ sock_define_const("MSG_FLUSH", MSG_FLUSH);
+#endif
+
+#ifdef MSG_HOLD
+ sock_define_const("MSG_HOLD", MSG_HOLD);
+#endif
+
+#ifdef MSG_SEND
+ sock_define_const("MSG_SEND", MSG_SEND);
+#endif
+
+#ifdef MSG_HAVEMORE
+ sock_define_const("MSG_HAVEMORE", MSG_HAVEMORE);
+#endif
+
+#ifdef MSG_RCVMORE
+ sock_define_const("MSG_RCVMORE", MSG_RCVMORE);
+#endif
+
+#ifdef MSG_COMPAT
+ sock_define_const("MSG_COMPAT", MSG_COMPAT);
+#endif
+
+#ifdef SOL_SOCKET
+ sock_define_const("SOL_SOCKET", SOL_SOCKET);
+#endif
+
+#ifdef SOL_IP
+ sock_define_const("SOL_IP", SOL_IP);
+#endif
+
+#ifdef SOL_IPX
+ sock_define_const("SOL_IPX", SOL_IPX);
+#endif
+
+#ifdef SOL_AX25
+ sock_define_const("SOL_AX25", SOL_AX25);
+#endif
+
+#ifdef SOL_ATALK
+ sock_define_const("SOL_ATALK", SOL_ATALK);
+#endif
+
+#ifdef SOL_TCP
+ sock_define_const("SOL_TCP", SOL_TCP);
+#endif
+
+#ifdef SOL_UDP
+ sock_define_const("SOL_UDP", SOL_UDP);
+#endif
+
+#ifdef IPPROTO_IP
+ sock_define_const("IPPROTO_IP", IPPROTO_IP);
+#else
+ sock_define_const("IPPROTO_IP", 0);
+#endif
+
+#ifdef IPPROTO_ICMP
+ sock_define_const("IPPROTO_ICMP", IPPROTO_ICMP);
+#else
+ sock_define_const("IPPROTO_ICMP", 1);
+#endif
+
+#ifdef IPPROTO_IGMP
+ sock_define_const("IPPROTO_IGMP", IPPROTO_IGMP);
+#endif
+
+#ifdef IPPROTO_GGP
+ sock_define_const("IPPROTO_GGP", IPPROTO_GGP);
+#endif
+
+#ifdef IPPROTO_TCP
+ sock_define_const("IPPROTO_TCP", IPPROTO_TCP);
+#else
+ sock_define_const("IPPROTO_TCP", 6);
+#endif
+
+#ifdef IPPROTO_EGP
+ sock_define_const("IPPROTO_EGP", IPPROTO_EGP);
+#endif
+
+#ifdef IPPROTO_PUP
+ sock_define_const("IPPROTO_PUP", IPPROTO_PUP);
+#endif
+
+#ifdef IPPROTO_UDP
+ sock_define_const("IPPROTO_UDP", IPPROTO_UDP);
+#else
+ sock_define_const("IPPROTO_UDP", 17);
+#endif
+
+#ifdef IPPROTO_IDP
+ sock_define_const("IPPROTO_IDP", IPPROTO_IDP);
+#endif
+
+#ifdef IPPROTO_HELLO
+ sock_define_const("IPPROTO_HELLO", IPPROTO_HELLO);
+#endif
+
+#ifdef IPPROTO_ND
+ sock_define_const("IPPROTO_ND", IPPROTO_ND);
+#endif
+
+#ifdef IPPROTO_TP
+ sock_define_const("IPPROTO_TP", IPPROTO_TP);
+#endif
+
+#ifdef IPPROTO_XTP
+ sock_define_const("IPPROTO_XTP", IPPROTO_XTP);
+#endif
+
+#ifdef IPPROTO_EON
+ sock_define_const("IPPROTO_EON", IPPROTO_EON);
+#endif
+
+#ifdef IPPROTO_BIP
+ sock_define_const("IPPROTO_BIP", IPPROTO_BIP);
+#endif
+
+#ifdef IPPROTO_AH
+ sock_define_const("IPPROTO_AH", IPPROTO_AH);
+#endif
+
+#ifdef IPPROTO_DSTOPTS
+ sock_define_const("IPPROTO_DSTOPTS", IPPROTO_DSTOPTS);
+#endif
+
+#ifdef IPPROTO_ESP
+ sock_define_const("IPPROTO_ESP", IPPROTO_ESP);
+#endif
+
+#ifdef IPPROTO_FRAGMENT
+ sock_define_const("IPPROTO_FRAGMENT", IPPROTO_FRAGMENT);
+#endif
+
+#ifdef IPPROTO_HOPOPTS
+ sock_define_const("IPPROTO_HOPOPTS", IPPROTO_HOPOPTS);
+#endif
+
+#ifdef IPPROTO_ICMPV6
+ sock_define_const("IPPROTO_ICMPV6", IPPROTO_ICMPV6);
+#endif
+
+#ifdef IPPROTO_IPV6
+ sock_define_const("IPPROTO_IPV6", IPPROTO_IPV6);
+#endif
+
+#ifdef IPPROTO_NONE
+ sock_define_const("IPPROTO_NONE", IPPROTO_NONE);
+#endif
+
+#ifdef IPPROTO_ROUTING
+ sock_define_const("IPPROTO_ROUTING", IPPROTO_ROUTING);
+#endif
+
+#ifdef IPPROTO_RAW
+ sock_define_const("IPPROTO_RAW", IPPROTO_RAW);
+#else
+ sock_define_const("IPPROTO_RAW", 255);
+#endif
+
+#ifdef IPPROTO_MAX
+ sock_define_const("IPPROTO_MAX", IPPROTO_MAX);
+#endif
+
+#ifdef IPPORT_RESERVED
+ sock_define_const("IPPORT_RESERVED", IPPORT_RESERVED);
+#else
+ sock_define_const("IPPORT_RESERVED", 1024);
+#endif
+
+#ifdef IPPORT_USERRESERVED
+ sock_define_const("IPPORT_USERRESERVED", IPPORT_USERRESERVED);
+#else
+ sock_define_const("IPPORT_USERRESERVED", 5000);
+#endif
+
+#ifdef INADDR_ANY
+ sock_define_const("INADDR_ANY", INADDR_ANY);
+#else
+ sock_define_const("INADDR_ANY", 0x00000000);
+#endif
+
+#ifdef INADDR_BROADCAST
+ sock_define_const("INADDR_BROADCAST", INADDR_BROADCAST);
+#else
+ sock_define_const("INADDR_BROADCAST", 0xffffffff);
+#endif
+
+#ifdef INADDR_LOOPBACK
+ sock_define_const("INADDR_LOOPBACK", INADDR_LOOPBACK);
+#else
+ sock_define_const("INADDR_LOOPBACK", 0x7F000001);
+#endif
+
+#ifdef INADDR_UNSPEC_GROUP
+ sock_define_const("INADDR_UNSPEC_GROUP", INADDR_UNSPEC_GROUP);
+#else
+ sock_define_const("INADDR_UNSPEC_GROUP", 0xe0000000);
+#endif
+
+#ifdef INADDR_ALLHOSTS_GROUP
+ sock_define_const("INADDR_ALLHOSTS_GROUP", INADDR_ALLHOSTS_GROUP);
+#else
+ sock_define_const("INADDR_ALLHOSTS_GROUP", 0xe0000001);
+#endif
+
+#ifdef INADDR_MAX_LOCAL_GROUP
+ sock_define_const("INADDR_MAX_LOCAL_GROUP", INADDR_MAX_LOCAL_GROUP);
+#else
+ sock_define_const("INADDR_MAX_LOCAL_GROUP", 0xe00000ff);
+#endif
+
+#ifdef INADDR_NONE
+ sock_define_const("INADDR_NONE", INADDR_NONE);
+#else
+ sock_define_const("INADDR_NONE", 0xffffffff);
+#endif
+
+#ifdef IP_OPTIONS
+ sock_define_const("IP_OPTIONS", IP_OPTIONS);
+#endif
+
+#ifdef IP_HDRINCL
+ sock_define_const("IP_HDRINCL", IP_HDRINCL);
+#endif
+
+#ifdef IP_TOS
+ sock_define_const("IP_TOS", IP_TOS);
+#endif
+
+#ifdef IP_TTL
+ sock_define_const("IP_TTL", IP_TTL);
+#endif
+
+#ifdef IP_RECVOPTS
+ sock_define_const("IP_RECVOPTS", IP_RECVOPTS);
+#endif
+
+#ifdef IP_RECVRETOPTS
+ sock_define_const("IP_RECVRETOPTS", IP_RECVRETOPTS);
+#endif
+
+#ifdef IP_RECVDSTADDR
+ sock_define_const("IP_RECVDSTADDR", IP_RECVDSTADDR);
+#endif
+
+#ifdef IP_RETOPTS
+ sock_define_const("IP_RETOPTS", IP_RETOPTS);
+#endif
+
+#ifdef IP_MULTICAST_IF
+ sock_define_const("IP_MULTICAST_IF", IP_MULTICAST_IF);
+#endif
+
+#ifdef IP_MULTICAST_TTL
+ sock_define_const("IP_MULTICAST_TTL", IP_MULTICAST_TTL);
+#endif
+
+#ifdef IP_MULTICAST_LOOP
+ sock_define_const("IP_MULTICAST_LOOP", IP_MULTICAST_LOOP);
+#endif
+
+#ifdef IP_ADD_MEMBERSHIP
+ sock_define_const("IP_ADD_MEMBERSHIP", IP_ADD_MEMBERSHIP);
+#endif
+
+#ifdef IP_DROP_MEMBERSHIP
+ sock_define_const("IP_DROP_MEMBERSHIP", IP_DROP_MEMBERSHIP);
+#endif
+
+#ifdef IP_DEFAULT_MULTICAST_TTL
+ sock_define_const("IP_DEFAULT_MULTICAST_TTL", IP_DEFAULT_MULTICAST_TTL);
+#endif
+
+#ifdef IP_DEFAULT_MULTICAST_LOOP
+ sock_define_const("IP_DEFAULT_MULTICAST_LOOP", IP_DEFAULT_MULTICAST_LOOP);
+#endif
+
+#ifdef IP_MAX_MEMBERSHIPS
+ sock_define_const("IP_MAX_MEMBERSHIPS", IP_MAX_MEMBERSHIPS);
+#endif
+
+#ifdef SO_DEBUG
+ sock_define_const("SO_DEBUG", SO_DEBUG);
+#endif
+
+#ifdef SO_REUSEADDR
+ sock_define_const("SO_REUSEADDR", SO_REUSEADDR);
+#endif
+
+#ifdef SO_REUSEPORT
+ sock_define_const("SO_REUSEPORT", SO_REUSEPORT);
+#endif
+
+#ifdef SO_TYPE
+ sock_define_const("SO_TYPE", SO_TYPE);
+#endif
+
+#ifdef SO_ERROR
+ sock_define_const("SO_ERROR", SO_ERROR);
+#endif
+
+#ifdef SO_DONTROUTE
+ sock_define_const("SO_DONTROUTE", SO_DONTROUTE);
+#endif
+
+#ifdef SO_BROADCAST
+ sock_define_const("SO_BROADCAST", SO_BROADCAST);
+#endif
+
+#ifdef SO_SNDBUF
+ sock_define_const("SO_SNDBUF", SO_SNDBUF);
+#endif
+
+#ifdef SO_RCVBUF
+ sock_define_const("SO_RCVBUF", SO_RCVBUF);
+#endif
+
+#ifdef SO_KEEPALIVE
+ sock_define_const("SO_KEEPALIVE", SO_KEEPALIVE);
+#endif
+
+#ifdef SO_OOBINLINE
+ sock_define_const("SO_OOBINLINE", SO_OOBINLINE);
+#endif
+
+#ifdef SO_NO_CHECK
+ sock_define_const("SO_NO_CHECK", SO_NO_CHECK);
+#endif
+
+#ifdef SO_PRIORITY
+ sock_define_const("SO_PRIORITY", SO_PRIORITY);
+#endif
+
+#ifdef SO_LINGER
+ sock_define_const("SO_LINGER", SO_LINGER);
+#endif
+
+#ifdef SO_PASSCRED
+ sock_define_const("SO_PASSCRED", SO_PASSCRED);
+#endif
+
+#ifdef SO_PEERCRED
+ sock_define_const("SO_PEERCRED", SO_PEERCRED);
+#endif
+
+#ifdef SO_RCVLOWAT
+ sock_define_const("SO_RCVLOWAT", SO_RCVLOWAT);
+#endif
+
+#ifdef SO_SNDLOWAT
+ sock_define_const("SO_SNDLOWAT", SO_SNDLOWAT);
+#endif
+
+#ifdef SO_RCVTIMEO
+ sock_define_const("SO_RCVTIMEO", SO_RCVTIMEO);
+#endif
+
+#ifdef SO_SNDTIMEO
+ sock_define_const("SO_SNDTIMEO", SO_SNDTIMEO);
+#endif
+
+#ifdef SO_ACCEPTCONN
+ sock_define_const("SO_ACCEPTCONN", SO_ACCEPTCONN);
+#endif
+
+#ifdef SO_USELOOPBACK
+ sock_define_const("SO_USELOOPBACK", SO_USELOOPBACK);
+#endif
+
+#ifdef SO_ACCEPTFILTER
+ sock_define_const("SO_ACCEPTFILTER", SO_ACCEPTFILTER);
+#endif
+
+#ifdef SO_DONTTRUNC
+ sock_define_const("SO_DONTTRUNC", SO_DONTTRUNC);
+#endif
+
+#ifdef SO_WANTMORE
+ sock_define_const("SO_WANTMORE", SO_WANTMORE);
+#endif
+
+#ifdef SO_WANTOOBFLAG
+ sock_define_const("SO_WANTOOBFLAG", SO_WANTOOBFLAG);
+#endif
+
+#ifdef SO_NREAD
+ sock_define_const("SO_NREAD", SO_NREAD);
+#endif
+
+#ifdef SO_NKE
+ sock_define_const("SO_NKE", SO_NKE);
+#endif
+
+#ifdef SO_NOSIGPIPE
+ sock_define_const("SO_NOSIGPIPE", SO_NOSIGPIPE);
+#endif
+
+#ifdef SO_SECURITY_AUTHENTICATION
+ sock_define_const("SO_SECURITY_AUTHENTICATION", SO_SECURITY_AUTHENTICATION);
+#endif
+
+#ifdef SO_SECURITY_ENCRYPTION_TRANSPORT
+ sock_define_const("SO_SECURITY_ENCRYPTION_TRANSPORT", SO_SECURITY_ENCRYPTION_TRANSPORT);
+#endif
+
+#ifdef SO_SECURITY_ENCRYPTION_NETWORK
+ sock_define_const("SO_SECURITY_ENCRYPTION_NETWORK", SO_SECURITY_ENCRYPTION_NETWORK);
+#endif
+
+#ifdef SO_BINDTODEVICE
+ sock_define_const("SO_BINDTODEVICE", SO_BINDTODEVICE);
+#endif
+
+#ifdef SO_ATTACH_FILTER
+ sock_define_const("SO_ATTACH_FILTER", SO_ATTACH_FILTER);
+#endif
+
+#ifdef SO_DETACH_FILTER
+ sock_define_const("SO_DETACH_FILTER", SO_DETACH_FILTER);
+#endif
+
+#ifdef SO_PEERNAME
+ sock_define_const("SO_PEERNAME", SO_PEERNAME);
+#endif
+
+#ifdef SO_TIMESTAMP
+ sock_define_const("SO_TIMESTAMP", SO_TIMESTAMP);
+#endif
+
+#ifdef SOPRI_INTERACTIVE
+ sock_define_const("SOPRI_INTERACTIVE", SOPRI_INTERACTIVE);
+#endif
+
+#ifdef SOPRI_NORMAL
+ sock_define_const("SOPRI_NORMAL", SOPRI_NORMAL);
+#endif
+
+#ifdef SOPRI_BACKGROUND
+ sock_define_const("SOPRI_BACKGROUND", SOPRI_BACKGROUND);
+#endif
+
+#ifdef IPX_TYPE
+ sock_define_const("IPX_TYPE", IPX_TYPE);
+#endif
+
+#ifdef TCP_NODELAY
+ sock_define_const("TCP_NODELAY", TCP_NODELAY);
+#endif
+
+#ifdef TCP_MAXSEG
+ sock_define_const("TCP_MAXSEG", TCP_MAXSEG);
+#endif
+
+#ifdef EAI_ADDRFAMILY
+ sock_define_const("EAI_ADDRFAMILY", EAI_ADDRFAMILY);
+#endif
+
+#ifdef EAI_AGAIN
+ sock_define_const("EAI_AGAIN", EAI_AGAIN);
+#endif
+
+#ifdef EAI_BADFLAGS
+ sock_define_const("EAI_BADFLAGS", EAI_BADFLAGS);
+#endif
+
+#ifdef EAI_FAIL
+ sock_define_const("EAI_FAIL", EAI_FAIL);
+#endif
+
+#ifdef EAI_FAMILY
+ sock_define_const("EAI_FAMILY", EAI_FAMILY);
+#endif
+
+#ifdef EAI_MEMORY
+ sock_define_const("EAI_MEMORY", EAI_MEMORY);
+#endif
+
+#ifdef EAI_NODATA
+ sock_define_const("EAI_NODATA", EAI_NODATA);
+#endif
+
+#ifdef EAI_NONAME
+ sock_define_const("EAI_NONAME", EAI_NONAME);
+#endif
+
+#ifdef EAI_OVERFLOW
+ sock_define_const("EAI_OVERFLOW", EAI_OVERFLOW);
+#endif
+
+#ifdef EAI_SERVICE
+ sock_define_const("EAI_SERVICE", EAI_SERVICE);
+#endif
+
+#ifdef EAI_SOCKTYPE
+ sock_define_const("EAI_SOCKTYPE", EAI_SOCKTYPE);
+#endif
+
+#ifdef EAI_SYSTEM
+ sock_define_const("EAI_SYSTEM", EAI_SYSTEM);
+#endif
+
+#ifdef EAI_BADHINTS
+ sock_define_const("EAI_BADHINTS", EAI_BADHINTS);
+#endif
+
+#ifdef EAI_PROTOCOL
+ sock_define_const("EAI_PROTOCOL", EAI_PROTOCOL);
+#endif
+
+#ifdef EAI_MAX
+ sock_define_const("EAI_MAX", EAI_MAX);
+#endif
+
+#ifdef AI_PASSIVE
+ sock_define_const("AI_PASSIVE", AI_PASSIVE);
+#endif
+
+#ifdef AI_CANONNAME
+ sock_define_const("AI_CANONNAME", AI_CANONNAME);
+#endif
+
+#ifdef AI_NUMERICHOST
+ sock_define_const("AI_NUMERICHOST", AI_NUMERICHOST);
+#endif
+
+#ifdef AI_NUMERICSERV
+ sock_define_const("AI_NUMERICSERV", AI_NUMERICSERV);
+#endif
+
+#ifdef AI_MASK
+ sock_define_const("AI_MASK", AI_MASK);
+#endif
+
+#ifdef AI_ALL
+ sock_define_const("AI_ALL", AI_ALL);
+#endif
+
+#ifdef AI_V4MAPPED_CFG
+ sock_define_const("AI_V4MAPPED_CFG", AI_V4MAPPED_CFG);
+#endif
+
+#ifdef AI_ADDRCONFIG
+ sock_define_const("AI_ADDRCONFIG", AI_ADDRCONFIG);
+#endif
+
+#ifdef AI_V4MAPPED
+ sock_define_const("AI_V4MAPPED", AI_V4MAPPED);
+#endif
+
+#ifdef AI_DEFAULT
+ sock_define_const("AI_DEFAULT", AI_DEFAULT);
+#endif
+
+#ifdef NI_MAXHOST
+ sock_define_const("NI_MAXHOST", NI_MAXHOST);
+#endif
+
+#ifdef NI_MAXSERV
+ sock_define_const("NI_MAXSERV", NI_MAXSERV);
+#endif
+
+#ifdef NI_NOFQDN
+ sock_define_const("NI_NOFQDN", NI_NOFQDN);
+#endif
+
+#ifdef NI_NUMERICHOST
+ sock_define_const("NI_NUMERICHOST", NI_NUMERICHOST);
+#endif
+
+#ifdef NI_NAMEREQD
+ sock_define_const("NI_NAMEREQD", NI_NAMEREQD);
+#endif
+
+#ifdef NI_NUMERICSERV
+ sock_define_const("NI_NUMERICSERV", NI_NUMERICSERV);
+#endif
+
+#ifdef NI_DGRAM
+ sock_define_const("NI_DGRAM", NI_DGRAM);
+#endif
+
+#ifdef SHUT_RD
+ sock_define_const("SHUT_RD", SHUT_RD);
+#else
+ sock_define_const("SHUT_RD", 0);
+#endif
+
+#ifdef SHUT_WR
+ sock_define_const("SHUT_WR", SHUT_WR);
+#else
+ sock_define_const("SHUT_WR", 1);
+#endif
+
+#ifdef SHUT_RDWR
+ sock_define_const("SHUT_RDWR", SHUT_RDWR);
+#else
+ sock_define_const("SHUT_RDWR", 2);
+#endif
+
+#ifdef IPV6_JOIN_GROUP
+ sock_define_const("IPV6_JOIN_GROUP", IPV6_JOIN_GROUP);
+#endif
+
+#ifdef IPV6_LEAVE_GROUP
+ sock_define_const("IPV6_LEAVE_GROUP", IPV6_LEAVE_GROUP);
+#endif
+
+#ifdef IPV6_MULTICAST_HOPS
+ sock_define_const("IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS);
+#endif
+
+#ifdef IPV6_MULTICAST_IF
+ sock_define_const("IPV6_MULTICAST_IF", IPV6_MULTICAST_IF);
+#endif
+
+#ifdef IPV6_MULTICAST_LOOP
+ sock_define_const("IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP);
+#endif
+
+#ifdef IPV6_UNICAST_HOPS
+ sock_define_const("IPV6_UNICAST_HOPS", IPV6_UNICAST_HOPS);
+#endif
+
+#ifdef IPV6_V6ONLY
+ sock_define_const("IPV6_V6ONLY", IPV6_V6ONLY);
+#endif
+
+#ifdef IPV6_CHECKSUM
+ sock_define_const("IPV6_CHECKSUM", IPV6_CHECKSUM);
+#endif
+
+#ifdef IPV6_DONTFRAG
+ sock_define_const("IPV6_DONTFRAG", IPV6_DONTFRAG);
+#endif
+
+#ifdef IPV6_DSTOPTS
+ sock_define_const("IPV6_DSTOPTS", IPV6_DSTOPTS);
+#endif
+
+#ifdef IPV6_HOPLIMIT
+ sock_define_const("IPV6_HOPLIMIT", IPV6_HOPLIMIT);
+#endif
+
+#ifdef IPV6_HOPOPTS
+ sock_define_const("IPV6_HOPOPTS", IPV6_HOPOPTS);
+#endif
+
+#ifdef IPV6_NEXTHOP
+ sock_define_const("IPV6_NEXTHOP", IPV6_NEXTHOP);
+#endif
+
+#ifdef IPV6_PATHMTU
+ sock_define_const("IPV6_PATHMTU", IPV6_PATHMTU);
+#endif
+
+#ifdef IPV6_PKTINFO
+ sock_define_const("IPV6_PKTINFO", IPV6_PKTINFO);
+#endif
+
+#ifdef IPV6_RECVDSTOPTS
+ sock_define_const("IPV6_RECVDSTOPTS", IPV6_RECVDSTOPTS);
+#endif
+
+#ifdef IPV6_RECVHOPLIMIT
+ sock_define_const("IPV6_RECVHOPLIMIT", IPV6_RECVHOPLIMIT);
+#endif
+
+#ifdef IPV6_RECVHOPOPTS
+ sock_define_const("IPV6_RECVHOPOPTS", IPV6_RECVHOPOPTS);
+#endif
+
+#ifdef IPV6_RECVPKTINFO
+ sock_define_const("IPV6_RECVPKTINFO", IPV6_RECVPKTINFO);
+#endif
+
+#ifdef IPV6_RECVRTHDR
+ sock_define_const("IPV6_RECVRTHDR", IPV6_RECVRTHDR);
+#endif
+
+#ifdef IPV6_RECVTCLASS
+ sock_define_const("IPV6_RECVTCLASS", IPV6_RECVTCLASS);
+#endif
+
+#ifdef IPV6_RTHDR
+ sock_define_const("IPV6_RTHDR", IPV6_RTHDR);
+#endif
+
+#ifdef IPV6_RTHDRDSTOPTS
+ sock_define_const("IPV6_RTHDRDSTOPTS", IPV6_RTHDRDSTOPTS);
+#endif
+
+#ifdef IPV6_RTHDR_TYPE_0
+ sock_define_const("IPV6_RTHDR_TYPE_0", IPV6_RTHDR_TYPE_0);
+#endif
+
+#ifdef IPV6_RECVPATHMTU
+ sock_define_const("IPV6_RECVPATHMTU", IPV6_RECVPATHMTU);
+#endif
+
+#ifdef IPV6_TCLASS
+ sock_define_const("IPV6_TCLASS", IPV6_TCLASS);
+#endif
+
+#ifdef IPV6_USE_MIN_MTU
+ sock_define_const("IPV6_USE_MIN_MTU", IPV6_USE_MIN_MTU);
+#endif
+
+#ifdef INET_ADDRSTRLEN
+ sock_define_const("INET_ADDRSTRLEN", INET_ADDRSTRLEN);
+#endif
+
+#ifdef INET6_ADDRSTRLEN
+ sock_define_const("INET6_ADDRSTRLEN", INET6_ADDRSTRLEN);
+#endif
+
--- /dev/null
+ \
+ class Object; \
+ CROSS_COMPILING = RUBY_PLATFORM; \
+ remove_const :RUBY_PLATFORM; \
+ remove_const :RUBY_VERSION; \
+ RUBY_PLATFORM = "arm-linux"; \
+ RUBY_VERSION = "1.9.1"; \
+ end; \
+ if RUBY_PLATFORM =~ /mswin|bccwin|mingw/; \
+ class File; \
+ remove_const :ALT_SEPARATOR; \
+ ALT_SEPARATOR = "\\"; \
+ end; \
+ end; \
+
#if defined(HAVE_FORK)
int status;
struct popen_arg arg;
-#elif defined(_WIN32)
+#else
volatile VALUE argbuf;
char **args = NULL;
struct rb_exec_arg sarg;
ruby_sysinit(&argc, &argv);
{
- RUBY_INIT_STACK;
+// RUBY_INIT_STACK;
ruby_init();
return ruby_run_node(ruby_options(argc, argv));
}
}
return fd2;
#else
+#ifndef __BIONIC__
extern int errno;
+#endif
int i, fd, fds[256];
if (fd1 == fd2) return 0;
--- /dev/null
+#include "ruby/ruby.h"
+#include "vm_core.h"
+
+static const char prelude_name0[] = "<internal:prelude>";
+static const char prelude_code0[] =
+"\n"
+"# Mutex\n"
+"\n"
+"class Mutex\n"
+" def synchronize\n"
+" self.lock\n"
+" begin\n"
+" yield\n"
+" ensure\n"
+" self.unlock rescue nil\n"
+" end\n"
+" end\n"
+"end\n"
+"\n"
+"# Thread\n"
+"\n"
+"class Thread\n"
+" MUTEX_FOR_THREAD_EXCLUSIVE = Mutex.new\n"
+" def self.exclusive\n"
+" MUTEX_FOR_THREAD_EXCLUSIVE.synchronize{\n"
+" yield\n"
+" }\n"
+" end\n"
+"end\n"
+"\n"
+"def require_relative(relative_feature)\n"
+" c = caller.first\n"
+" e = c.rindex(/:\\d+:in /)\n"
+" file = $`\n"
+" if /\\A\\((.*)\\)/ =~ file # eval, etc.\n"
+" raise LoadError, \"require_relative is called in #{$1}\"\n"
+" end\n"
+" absolute_feature = File.expand_path(File.join(File.dirname(file), relative_feature))\n"
+" require absolute_feature\n"
+"end\n"
+;
+static const char prelude_name1[] = "<internal:prelude>";
+static const char prelude_code1[] =
+"%w'enc/encdb enc/trans/transdb'.each do |init|\n"
+" begin\n"
+" require(init)\n"
+" rescue LoadError\n"
+" end\n"
+"end\n"
+;
+static const char prelude_name2[] = "<internal:gem_prelude>";
+static const char prelude_code2[] =
+"TMP_RUBY_PREFIX = $:.reverse.find{|e|e!=\".\"}.sub(%r{(.*)/lib/.*}m, \"\\\\1\")\n"
+"# depends on: array.rb dir.rb env.rb file.rb hash.rb module.rb regexp.rb\n"
+"# vim: filetype=ruby\n"
+"# THIS FILE WAS AUTOGENERATED, DO NOT EDIT\n"
+"\n"
+"# NOTICE: Ruby is during initialization here. \n"
+"# * Encoding.default_external does not reflects -E.\n"
+"# * Should not expect Encoding.default_internal.\n"
+"# * Locale encoding is available.\n"
+"if defined?(Gem) then\n"
+"\n"
+" module Kernel\n"
+"\n"
+" def gem(gem_name, *version_requirements)\n"
+" Gem.push_gem_version_on_load_path(gem_name, *version_requirements)\n"
+" end\n"
+"\n"
+" end\n"
+"\n"
+" module Gem\n"
+"\n"
+" class LoadError < ::LoadError\n"
+" end\n"
+"\n"
+" ConfigMap = {\n"
+" :sitedir => \"#{TMP_RUBY_PREFIX}/lib/ruby/site_ruby\",\n"
+" :ruby_version => \"1.9.1\",\n"
+" :libdir => \"#{TMP_RUBY_PREFIX}/lib\",\n"
+" :sitelibdir => \"#{TMP_RUBY_PREFIX}/lib/ruby/site_ruby/1.9.1\",\n"
+" :arch => \"arm-linux\",\n"
+" :bindir => \"#{TMP_RUBY_PREFIX}/bin\",\n"
+" :EXEEXT => \"\",\n"
+" :RUBY_SO_NAME => \"ruby\",\n"
+" :ruby_install_name => \"ruby\"\n"
+" }\n"
+"\n"
+" def self.dir\n"
+" @gem_home ||= nil\n"
+" set_home(ENV['GEM_HOME'] || default_dir) unless @gem_home\n"
+" @gem_home\n"
+" end\n"
+"\n"
+" def self.path\n"
+" @gem_path ||= nil\n"
+" unless @gem_path\n"
+" paths = [ENV['GEM_PATH']]\n"
+" paths << APPLE_GEM_HOME if defined? APPLE_GEM_HOME\n"
+" set_paths(paths.compact.join(File::PATH_SEPARATOR))\n"
+" end\n"
+" @gem_path\n"
+" end\n"
+"\n"
+" def self.post_install(&hook)\n"
+" @post_install_hooks << hook\n"
+" end\n"
+"\n"
+" def self.post_uninstall(&hook)\n"
+" @post_uninstall_hooks << hook\n"
+" end\n"
+"\n"
+" def self.pre_install(&hook)\n"
+" @pre_install_hooks << hook\n"
+" end\n"
+"\n"
+" def self.pre_uninstall(&hook)\n"
+" @pre_uninstall_hooks << hook\n"
+" end\n"
+"\n"
+" def self.set_home(home)\n"
+" @gem_home = home\n"
+" ensure_gem_subdirectories(@gem_home)\n"
+" end\n"
+"\n"
+" def self.set_paths(gpaths)\n"
+" if gpaths\n"
+" @gem_path = gpaths.split(File::PATH_SEPARATOR)\n"
+" @gem_path << Gem.dir\n"
+" else\n"
+" @gem_path = [Gem.dir]\n"
+" end\n"
+" @gem_path.uniq!\n"
+" @gem_path.each do |gp| ensure_gem_subdirectories(gp) end\n"
+" end\n"
+"\n"
+" def self.ensure_gem_subdirectories(path)\n"
+" end\n"
+"\n"
+" \n"
+" @post_install_hooks ||= []\n"
+" @post_uninstall_hooks ||= []\n"
+" @pre_uninstall_hooks ||= []\n"
+" @pre_install_hooks ||= []\n"
+" \n"
+" ##\n"
+" # An Array of the default sources that come with RubyGems\n"
+" \n"
+" def self.default_sources\n"
+" %w[http://gems.rubyforge.org/]\n"
+" end\n"
+" \n"
+" ##\n"
+" # Default home directory path to be used if an alternate value is not\n"
+" # specified in the environment\n"
+" \n"
+" def self.default_dir\n"
+" if defined? RUBY_FRAMEWORK_VERSION then\n"
+" File.join File.dirname(ConfigMap[:sitedir]), 'Gems',\n"
+" ConfigMap[:ruby_version]\n"
+" elsif RUBY_VERSION > '1.9' then\n"
+" File.join(ConfigMap[:libdir], ConfigMap[:ruby_install_name], 'gems',\n"
+" ConfigMap[:ruby_version])\n"
+" else\n"
+" File.join(ConfigMap[:libdir], ruby_engine, 'gems',\n"
+" ConfigMap[:ruby_version])\n"
+" end\n"
+" end\n"
+" \n"
+" ##\n"
+" # Path for gems in the user's home directory\n"
+" \n"
+" def self.user_dir\n"
+" File.join(Gem.user_home, '.gem', ruby_engine,\n"
+" ConfigMap[:ruby_version])\n"
+" end\n"
+" \n"
+" ##\n"
+" # Default gem load path\n"
+" \n"
+" def self.default_path\n"
+" [user_dir, default_dir]\n"
+" end\n"
+" \n"
+" ##\n"
+" # Deduce Ruby's --program-prefix and --program-suffix from its install name\n"
+" \n"
+" def self.default_exec_format\n"
+" baseruby = ConfigMap[:BASERUBY] || 'ruby'\n"
+" ConfigMap[:RUBY_INSTALL_NAME].sub(baseruby, '%s') rescue '%s'\n"
+" end\n"
+" \n"
+" ##\n"
+" # The default directory for binaries\n"
+" \n"
+" def self.default_bindir\n"
+" if defined? RUBY_FRAMEWORK_VERSION then # mac framework support\n"
+" '/usr/bin'\n"
+" else # generic install\n"
+" ConfigMap[:bindir]\n"
+" end\n"
+" end\n"
+" \n"
+" ##\n"
+" # The default system-wide source info cache directory\n"
+" \n"
+" def self.default_system_source_cache_dir\n"
+" File.join Gem.dir, 'source_cache'\n"
+" end\n"
+" \n"
+" ##\n"
+" # The default user-specific source info cache directory\n"
+" \n"
+" def self.default_user_source_cache_dir\n"
+" File.join Gem.user_home, '.gem', 'source_cache'\n"
+" end\n"
+" \n"
+" ##\n"
+" # A wrapper around RUBY_ENGINE const that may not be defined\n"
+" \n"
+" def self.ruby_engine\n"
+" if defined? RUBY_ENGINE then\n"
+" RUBY_ENGINE\n"
+" else\n"
+" 'ruby'\n"
+" end\n"
+" end\n"
+" \n"
+" \n"
+"\n"
+" # Methods before this line will be removed when QuickLoader is replaced\n"
+" # with the real RubyGems\n"
+"\n"
+" GEM_PRELUDE_METHODS = Gem.methods(false)\n"
+"\n"
+" begin\n"
+" verbose, debug = $VERBOSE, $DEBUG\n"
+" $DEBUG = $VERBOSE = nil\n"
+"\n"
+" begin\n"
+" require 'rubygems/defaults/operating_system'\n"
+" rescue ::LoadError\n"
+" end\n"
+"\n"
+" if defined?(RUBY_ENGINE) then\n"
+" begin\n"
+" require \"rubygems/defaults/#{RUBY_ENGINE}\"\n"
+" rescue ::LoadError\n"
+" end\n"
+" end\n"
+" ensure\n"
+" $VERBOSE, $DEBUG = verbose, debug\n"
+" end\n"
+"\n"
+" module QuickLoader\n"
+"\n"
+" @loaded_full_rubygems_library = false\n"
+"\n"
+" def self.load_full_rubygems_library\n"
+" return if @loaded_full_rubygems_library\n"
+"\n"
+" @loaded_full_rubygems_library = true\n"
+"\n"
+" class << Gem\n"
+" Gem::GEM_PRELUDE_METHODS.each do |method_name|\n"
+" undef_method method_name\n"
+" end\n"
+" end\n"
+"\n"
+" Kernel.module_eval do\n"
+" undef_method :gem if method_defined? :gem\n"
+" end\n"
+"\n"
+" $\".delete File.join(Gem::ConfigMap[:libdir],\n"
+" Gem::ConfigMap[:ruby_install_name],\n"
+" Gem::ConfigMap[:ruby_version], 'rubygems.rb')\n"
+"\n"
+" require 'rubygems'\n"
+" end\n"
+"\n"
+" GemPaths = {}\n"
+" GemVersions = {}\n"
+"\n"
+" def push_gem_version_on_load_path(gem_name, *version_requirements)\n"
+" if version_requirements.empty?\n"
+" unless GemPaths.has_key?(gem_name)\n"
+" raise Gem::LoadError.new(\"Could not find RubyGem #{gem_name} (>= 0)\\n\")\n"
+" end\n"
+"\n"
+" # highest version gems already active\n"
+" return false\n"
+" else\n"
+" if version_requirements.length > 1\n"
+" QuickLoader.load_full_rubygems_library\n"
+" return gem(gem_name, *version_requirements)\n"
+" end\n"
+"\n"
+" requirement, version = version_requirements[0].split\n"
+" requirement.strip!\n"
+"\n"
+" if requirement == \">\" || requirement == \">=\"\n"
+" if (GemVersions[gem_name] <=> Gem.calculate_integers_for_gem_version(version)) >= 0\n"
+" return false\n"
+" end\n"
+" elsif requirement == \"~>\"\n"
+" loaded_version = GemVersions[gem_name]\n"
+" required_version = Gem.calculate_integers_for_gem_version(version)\n"
+" if loaded_version && (loaded_version[0] == required_version[0])\n"
+" return false\n"
+" end\n"
+" end\n"
+"\n"
+" QuickLoader.load_full_rubygems_library\n"
+" gem(gem_name, *version_requirements)\n"
+" end\n"
+" end\n"
+"\n"
+" def calculate_integers_for_gem_version(gem_version)\n"
+" numbers = gem_version.split(\".\").collect {|n| n.to_i}\n"
+" numbers.pop while numbers.last == 0\n"
+" numbers << 0 if numbers.empty?\n"
+" numbers\n"
+" end\n"
+"\n"
+" def push_all_highest_version_gems_on_load_path\n"
+" Gem.path.each do |path|\n"
+" gems_directory = File.join(path, \"gems\")\n"
+" if File.exist?(gems_directory)\n"
+" Dir.entries(gems_directory).each do |gem_directory_name|\n"
+" next if gem_directory_name == \".\" || gem_directory_name == \"..\"\n"
+" dash = gem_directory_name.rindex(\"-\")\n"
+" next if dash.nil?\n"
+" gem_name = gem_directory_name[0...dash]\n"
+" current_version = GemVersions[gem_name]\n"
+" new_version = calculate_integers_for_gem_version(gem_directory_name[dash+1..-1])\n"
+" if current_version\n"
+" if (current_version <=> new_version) == -1\n"
+" GemVersions[gem_name] = new_version\n"
+" GemPaths[gem_name] = File.join(gems_directory, gem_directory_name)\n"
+" end\n"
+" else\n"
+" GemVersions[gem_name] = new_version\n"
+" GemPaths[gem_name] = File.join(gems_directory, gem_directory_name)\n"
+" end\n"
+" end\n"
+" end\n"
+" end\n"
+"\n"
+" require_paths = []\n"
+"\n"
+" GemPaths.each_value do |path|\n"
+" if File.exist?(file = File.join(path, \".require_paths\")) then\n"
+" paths = File.read(file).split.map do |require_path|\n"
+" File.join path, require_path\n"
+" end\n"
+"\n"
+" require_paths.concat paths\n"
+" else\n"
+" require_paths << file if File.exist?(file = File.join(path, \"bin\"))\n"
+" require_paths << file if File.exist?(file = File.join(path, \"lib\"))\n"
+" end\n"
+" end\n"
+"\n"
+" # \"tag\" the first require_path inserted into the $LOAD_PATH to enable\n"
+" # indexing correctly with rubygems proper when it inserts an explicitly\n"
+" # gem version\n"
+" unless require_paths.empty?\n"
+" require_paths.first.instance_variable_set(:@gem_prelude_index, true)\n"
+" end\n"
+" # gem directories must come after -I and ENV['RUBYLIB']\n"
+" $:[$:.index(ConfigMap[:sitelibdir]),0] = require_paths\n"
+" end\n"
+"\n"
+" def const_missing(constant)\n"
+" QuickLoader.load_full_rubygems_library\n"
+" if Gem.const_defined?(constant)\n"
+" Gem.const_get(constant)\n"
+" else\n"
+" super\n"
+" end\n"
+" end\n"
+"\n"
+" def method_missing(method, *args, &block)\n"
+" QuickLoader.load_full_rubygems_library\n"
+" super unless Gem.respond_to?(method)\n"
+" Gem.send(method, *args, &block)\n"
+" end\n"
+" end\n"
+"\n"
+" extend QuickLoader\n"
+"\n"
+" end\n"
+"\n"
+" begin\n"
+" Gem.push_all_highest_version_gems_on_load_path\n"
+" $\" << File.join(Gem::ConfigMap[:libdir], Gem::ConfigMap[:ruby_install_name],\n"
+" Gem::ConfigMap[:ruby_version], \"rubygems.rb\")\n"
+" rescue Exception => e\n"
+" puts \"Error loading gem paths on load path in gem_prelude\"\n"
+" puts e\n"
+" puts e.backtrace.join(\"\\n\")\n"
+" end\n"
+"\n"
+"end\n"
+"\n"
+"Object.class_eval { remove_const \"TMP_RUBY_PREFIX\" }"
+;
+
+void
+Init_prelude(void)
+{
+ rb_iseq_eval(rb_iseq_compile(
+ rb_str_new(prelude_code0, sizeof(prelude_code0) - 1),
+ rb_str_new(prelude_name0, sizeof(prelude_name0) - 1),
+ INT2FIX(1)));
+
+ rb_iseq_eval(rb_iseq_compile(
+ rb_str_new(prelude_code1, sizeof(prelude_code1) - 1),
+ rb_str_new(prelude_name1, sizeof(prelude_name1) - 1),
+ INT2FIX(1)));
+
+ rb_iseq_eval(rb_iseq_compile(
+ rb_str_new(prelude_code2, sizeof(prelude_code2) - 1),
+ rb_str_new(prelude_name2, sizeof(prelude_name2) - 1),
+ INT2FIX(0)));
+
+#if 0
+ puts(prelude_code0);
+ puts(prelude_code1);
+ puts(prelude_code2);
+#endif
+}
--- /dev/null
+
+# This file was created by mkconfig.rb when ruby was built. Any
+# changes made to this file will be lost the next time ruby is built.
+
+module RbConfig
+ RUBY_VERSION == "1.9.1" or
+ raise "ruby lib version (1.9.1) doesn't match executable version (#{RUBY_VERSION})"
+
+ TOPDIR = File.dirname(__FILE__).chomp!("/lib/ruby/1.9.1/arm-linux")
+ DESTDIR = '' unless defined? DESTDIR
+ CONFIG = {}
+ CONFIG["DESTDIR"] = DESTDIR
+ CONFIG["INSTALL"] = '/usr/bin/install -c'
+ CONFIG["EXEEXT"] = ""
+ CONFIG["prefix"] = (TOPDIR || DESTDIR + "/usr/local")
+ CONFIG["ruby_install_name"] = "ruby"
+ CONFIG["RUBY_INSTALL_NAME"] = "ruby"
+ CONFIG["RUBY_SO_NAME"] = "ruby"
+ CONFIG["BUILTIN_TRANSSRCS"] = " newline.c"
+ CONFIG["MANTYPE"] = "doc"
+ CONFIG["NROFF"] = "/usr/bin/nroff"
+ CONFIG["vendorhdrdir"] = "$(rubyhdrdir)/vendor_ruby"
+ CONFIG["sitehdrdir"] = "$(rubyhdrdir)/site_ruby"
+ CONFIG["rubyhdrdir"] = "$(includedir)/$(RUBY_INSTALL_NAME)-$(ruby_version)"
+ CONFIG["configure_args"] = " '--build=arm-android-linux' '--target=arm-android-linux' '--host=i686-linux' '--with-static-linked-ext' '--enable-wide-getaddrinfo' 'build_alias=arm-android-linux' 'host_alias=i686-linux' 'target_alias=arm-android-linux' 'CC=/home/sakamoto/android/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm-eabi-gcc' 'LIBS=-nostdlib -L/home/sakamoto/android/out/target/product/dream/obj/lib /home/sakamoto/android/out/target/product/dream/obj/lib/crtbegin_dynamic.o -lstdc++ -lc -lm -ldl /home/sakamoto/android/out/target/product/dream/obj/lib/crtend_android.o -Wl,-dynamic-linker,/system/bin/linker,-rpath,/system/lib' 'CPPFLAGS=-nostdinc -I/home/sakamoto/android/external/zlib -I/home/sakamoto/android/external/openssl/include -I/home/sakamoto/android/bionic/libc/include -I/home/sakamoto/android/bionic/libc/arch-arm/include -I/home/sakamoto/android/bionic/libc/kernel/common -I/home/sakamoto/android/bionic/libc/kernel/arch-arm -I/home/sakamoto/android/bionic/libc/kernel/common/linux -I/home/sakamoto/android/bionic/libm/include -I/home/sakamoto/android/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/lib/gcc/arm-eabi/4.2.1/include -Dptrdiff_t=__ptrdiff_t -include stdio.h -include unistd.h -include fcntl.h -include sys/mman.h -DHAVE_GETCWD'"
+ CONFIG["vendordir"] = "$(libdir)/$(RUBY_INSTALL_NAME)/vendor_ruby"
+ CONFIG["sitedir"] = "$(libdir)/$(RUBY_INSTALL_NAME)/site_ruby"
+ CONFIG["ruby_version"] = "1.9.1"
+ CONFIG["sitearch"] = "arm-linux"
+ CONFIG["arch"] = "arm-linux"
+ CONFIG["MAKEFILES"] = "Makefile"
+ CONFIG["THREAD_MODEL"] = "pthread"
+ CONFIG["EXPORT_PREFIX"] = ""
+ CONFIG["COMMON_HEADERS"] = ""
+ CONFIG["COMMON_MACROS"] = ""
+ CONFIG["COMMON_LIBS"] = ""
+ CONFIG["MAINLIBS"] = ""
+ CONFIG["ENABLE_SHARED"] = "no"
+ CONFIG["DLDLIBS"] = " -lc"
+ CONFIG["SOLIBS"] = ""
+ CONFIG["LIBRUBYARG_SHARED"] = "-Wl,-R -Wl,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)"
+ CONFIG["LIBRUBYARG_STATIC"] = "-Wl,-R -Wl,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static"
+ CONFIG["LIBRUBYARG"] = "$(LIBRUBYARG_STATIC)"
+ CONFIG["LIBRUBY"] = "$(LIBRUBY_A)"
+ CONFIG["LIBRUBY_ALIASES"] = "lib$(RUBY_SO_NAME).so"
+ CONFIG["LIBRUBY_SO"] = "lib$(RUBY_SO_NAME).so.$(MAJOR).$(MINOR).$(TEENY)"
+ CONFIG["LIBRUBY_A"] = "lib$(RUBY_SO_NAME)-static.a"
+ CONFIG["RUBYW_INSTALL_NAME"] = ""
+ CONFIG["rubyw_install_name"] = ""
+ CONFIG["LIBRUBY_DLDFLAGS"] = ""
+ CONFIG["LIBRUBY_LDSHARED"] = "$(CC) -shared"
+ CONFIG["warnflags"] = "-Wall -Wno-parentheses"
+ CONFIG["debugflags"] = ""
+ CONFIG["optflags"] = "-O2"
+ CONFIG["cflags"] = "$(optflags) $(debugflags) $(warnflags)"
+ CONFIG["cppflags"] = "-nostdinc -I/home/sakamoto/android/external/zlib -I/home/sakamoto/android/external/openssl/include -I/home/sakamoto/android/bionic/libc/include -I/home/sakamoto/android/bionic/libc/arch-arm/include -I/home/sakamoto/android/bionic/libc/kernel/common -I/home/sakamoto/android/bionic/libc/kernel/arch-arm -I/home/sakamoto/android/bionic/libc/kernel/common/linux -I/home/sakamoto/android/bionic/libm/include -I/home/sakamoto/android/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/lib/gcc/arm-eabi/4.2.1/include -Dptrdiff_t=__ptrdiff_t -include stdio.h -include unistd.h -include fcntl.h -include sys/mman.h -DHAVE_GETCWD"
+ CONFIG["RDOCTARGET"] = "install-doc"
+ CONFIG["ARCHFILE"] = ""
+ CONFIG["EXTOUT"] = ".ext"
+ CONFIG["PREP"] = "fake.rb"
+ CONFIG["setup"] = "Setup"
+ CONFIG["EXTSTATIC"] = "static"
+ CONFIG["STRIP"] = "strip -S -x"
+ CONFIG["TRY_LINK"] = ""
+ CONFIG["LIBPATHENV"] = "LD_LIBRARY_PATH"
+ CONFIG["RPATHFLAG"] = " -Wl,-R%1$-s"
+ CONFIG["LIBPATHFLAG"] = " -L%1$-s"
+ CONFIG["LINK_SO"] = ""
+ CONFIG["LIBEXT"] = "a"
+ CONFIG["DLEXT2"] = ""
+ CONFIG["DLEXT"] = "so"
+ CONFIG["LDSHAREDXX"] = "$(CXX) -shared"
+ CONFIG["LDSHARED"] = "$(CC) -shared"
+ CONFIG["CCDLFLAGS"] = " -fPIC"
+ CONFIG["STATIC"] = ""
+ CONFIG["ARCH_FLAG"] = ""
+ CONFIG["DLDFLAGS"] = ""
+ CONFIG["ALLOCA"] = ""
+ CONFIG["MAKEDIRS"] = "mkdir -p"
+ CONFIG["CP"] = "cp"
+ CONFIG["RM"] = "rm -f"
+ CONFIG["INSTALL_DATA"] = "$(INSTALL) -m 644"
+ CONFIG["INSTALL_SCRIPT"] = "$(INSTALL)"
+ CONFIG["INSTALL_PROGRAM"] = "$(INSTALL)"
+ CONFIG["SET_MAKE"] = ""
+ CONFIG["LN_S"] = "ln -s"
+ CONFIG["DLLWRAP"] = ""
+ CONFIG["WINDRES"] = ""
+ CONFIG["NM"] = ""
+ CONFIG["OBJCOPY"] = "objcopy"
+ CONFIG["OBJDUMP"] = "objdump"
+ CONFIG["ASFLAGS"] = ""
+ CONFIG["AS"] = "as"
+ CONFIG["AR"] = "/home/sakamoto/android/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm-eabi-ar"
+ CONFIG["RANLIB"] = "/home/sakamoto/android/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm-eabi-ranlib"
+ CONFIG["COUTFLAG"] = "-o "
+ CONFIG["OUTFLAG"] = "-o "
+ CONFIG["CPPOUTFILE"] = "-o conftest.i"
+ CONFIG["GNU_LD"] = "yes"
+ CONFIG["EGREP"] = "/bin/grep -E"
+ CONFIG["GREP"] = "/bin/grep"
+ CONFIG["CPP"] = "/home/sakamoto/android/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm-eabi-gcc -E"
+ CONFIG["CXXFLAGS"] = " -O2 -Wall -Wno-parentheses"
+ CONFIG["CXX"] = "g++"
+ CONFIG["OBJEXT"] = "o"
+ CONFIG["CPPFLAGS"] = "-nostdinc -I/home/sakamoto/android/external/zlib -I/home/sakamoto/android/external/openssl/include -I/home/sakamoto/android/bionic/libc/include -I/home/sakamoto/android/bionic/libc/arch-arm/include -I/home/sakamoto/android/bionic/libc/kernel/common -I/home/sakamoto/android/bionic/libc/kernel/arch-arm -I/home/sakamoto/android/bionic/libc/kernel/common/linux -I/home/sakamoto/android/bionic/libm/include -I/home/sakamoto/android/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/lib/gcc/arm-eabi/4.2.1/include -Dptrdiff_t=__ptrdiff_t -include stdio.h -include unistd.h -include fcntl.h -include sys/mman.h -DHAVE_GETCWD $(DEFS) $(cppflags)"
+ CONFIG["LDFLAGS"] = "-L. -Wl,-export-dynamic"
+ CONFIG["CFLAGS"] = " -O2 -Wall -Wno-parentheses"
+ CONFIG["CC"] = "/home/sakamoto/android/prebuilt/linux-x86/toolchain/arm-eabi-4.2.1/bin/arm-eabi-gcc"
+ CONFIG["target_os"] = "linux"
+ CONFIG["target_vendor"] = "android"
+ CONFIG["target_cpu"] = "arm"
+ CONFIG["target"] = "arm-android-linux-gnu"
+ CONFIG["host_os"] = "linux-gnu"
+ CONFIG["host_vendor"] = "pc"
+ CONFIG["host_cpu"] = "i686"
+ CONFIG["host"] = "i686-pc-linux-gnu"
+ CONFIG["build_os"] = "linux-gnu"
+ CONFIG["build_vendor"] = "android"
+ CONFIG["build_cpu"] = "arm"
+ CONFIG["build"] = "arm-android-linux-gnu"
+ CONFIG["TEENY"] = "1"
+ CONFIG["MINOR"] = "9"
+ CONFIG["MAJOR"] = "1"
+ CONFIG["BASERUBY"] = "ruby"
+ CONFIG["target_alias"] = "arm-android-linux"
+ CONFIG["host_alias"] = "i686-linux"
+ CONFIG["build_alias"] = "arm-android-linux"
+ CONFIG["LIBS"] = "-ldl -lm -nostdlib -L/home/sakamoto/android/out/target/product/dream/obj/lib /home/sakamoto/android/out/target/product/dream/obj/lib/crtbegin_dynamic.o -lstdc++ -lc -lm -ldl /home/sakamoto/android/out/target/product/dream/obj/lib/crtend_android.o -Wl,-dynamic-linker,/system/bin/linker,-rpath,/system/lib"
+ CONFIG["ECHO_T"] = ""
+ CONFIG["ECHO_N"] = "-n"
+ CONFIG["ECHO_C"] = ""
+ CONFIG["DEFS"] = ""
+ CONFIG["mandir"] = "$(datarootdir)/man"
+ CONFIG["localedir"] = "$(datarootdir)/locale"
+ CONFIG["libdir"] = "$(exec_prefix)/lib"
+ CONFIG["psdir"] = "$(docdir)"
+ CONFIG["pdfdir"] = "$(docdir)"
+ CONFIG["dvidir"] = "$(docdir)"
+ CONFIG["htmldir"] = "$(docdir)"
+ CONFIG["infodir"] = "$(datarootdir)/info"
+ CONFIG["docdir"] = "$(datarootdir)/doc/$(PACKAGE)"
+ CONFIG["oldincludedir"] = "/usr/include"
+ CONFIG["includedir"] = "$(prefix)/include"
+ CONFIG["localstatedir"] = "$(prefix)/var"
+ CONFIG["sharedstatedir"] = "$(prefix)/com"
+ CONFIG["sysconfdir"] = "$(prefix)/etc"
+ CONFIG["datadir"] = "$(datarootdir)"
+ CONFIG["datarootdir"] = "$(prefix)/share"
+ CONFIG["libexecdir"] = "$(exec_prefix)/libexec"
+ CONFIG["sbindir"] = "$(exec_prefix)/sbin"
+ CONFIG["bindir"] = "$(exec_prefix)/bin"
+ CONFIG["exec_prefix"] = "$(prefix)"
+ CONFIG["PACKAGE_BUGREPORT"] = ""
+ CONFIG["PACKAGE_STRING"] = ""
+ CONFIG["PACKAGE_VERSION"] = ""
+ CONFIG["PACKAGE_TARNAME"] = ""
+ CONFIG["PACKAGE_NAME"] = ""
+ CONFIG["PATH_SEPARATOR"] = ":"
+ CONFIG["SHELL"] = "/bin/bash"
+ CONFIG["rubylibdir"] = "$(libdir)/$(ruby_install_name)/$(ruby_version)"
+ CONFIG["archdir"] = "$(rubylibdir)/$(arch)"
+ CONFIG["sitelibdir"] = "$(sitedir)/$(ruby_version)"
+ CONFIG["sitearchdir"] = "$(sitelibdir)/$(sitearch)"
+ CONFIG["vendorlibdir"] = "$(vendordir)/$(ruby_version)"
+ CONFIG["vendorarchdir"] = "$(vendorlibdir)/$(sitearch)"
+ CONFIG["topdir"] = File.dirname(__FILE__)
+ MAKEFILE_CONFIG = {}
+ CONFIG.each{|k,v| MAKEFILE_CONFIG[k] = v.dup}
+ def RbConfig::expand(val, config = CONFIG)
+ val.gsub!(/\$\$|\$\(([^()]+)\)|\$\{([^{}]+)\}/) do
+ var = $&
+ if !(v = $1 || $2)
+ '$'
+ elsif key = config[v = v[/\A[^:]+(?=(?::(.*?)=(.*))?\z)/]]
+ pat, sub = $1, $2
+ config[v] = false
+ RbConfig::expand(key, config)
+ config[v] = key
+ key = key.gsub(/#{Regexp.quote(pat)}(?=\s|\z)/n) {sub} if pat
+ key
+ else
+ var
+ end
+ end
+ val
+ end
+ CONFIG.each_value do |val|
+ RbConfig::expand(val)
+ end
+end
+Config = RbConfig # compatibility for ruby-1.8.4 and older.
+CROSS_COMPILING = nil unless defined? CROSS_COMPILING
VALUE rb_get_load_path(void);
+#ifdef __BIONIC__
+#define mblen(a,b) 1
+#endif
+
#ifndef CharNext /* defined as CharNext[AW] on Windows. */
#define CharNext(p) ((p) + mblen(p, RUBY_MBCHAR_MAXSIZE))
#endif
--- /dev/null
+#ifndef RUBYEXTCONF_H
+#define RUBYEXTCONF_H
+
+#define BASE 10000UL
+#define BASE_FIG 4
+#define ENABLE_IPV6 1
+#define FIONREAD_HEADER <sys/ioctl.h>
+#define HAVE_ARPA_INET_H 1
+#define HAVE_ASSERT_H 1
+#define HAVE_BN_MOD_ADD 1
+#define HAVE_BN_MOD_SQR 1
+#define HAVE_BN_MOD_SUB 1
+#define HAVE_BN_PSEUDO_RAND_RANGE 1
+#define HAVE_BN_RAND_RANGE 1
+#define HAVE_CONFIG_H 1
+#define HAVE_CONF_GET1_DEFAULT_CONFIG_FILE 1
+#define HAVE_DLCLOSE 1
+#define HAVE_DLERROR 1
+#define HAVE_DLFCN_H 1
+#define HAVE_DLOPEN 1
+#define HAVE_DLSYM 1
+#define HAVE_ENGINE_ADD 1
+#define HAVE_ENGINE_CLEANUP 1
+#define HAVE_ENGINE_GET_CIPHER 1
+#define HAVE_ENGINE_GET_DIGEST 1
+#define HAVE_ENGINE_LOAD_BUILTIN_ENGINES 1
+#define HAVE_ERR_PEEK_LAST_ERROR 1
+#define HAVE_EVP_CIPHERFINAL_EX 1
+#define HAVE_EVP_CIPHERINIT_EX 1
+#define HAVE_EVP_CIPHER_CTX_ENGINE 1
+#define HAVE_EVP_CIPHER_CTX_FLAGS 1
+#define HAVE_EVP_CIPHER_CTX_SET_PADDING 1
+#define HAVE_EVP_DIGESTFINAL_EX 1
+#define HAVE_EVP_DIGESTINIT_EX 1
+#define HAVE_EVP_MD_CTX_CLEANUP 1
+#define HAVE_EVP_MD_CTX_CREATE 1
+#define HAVE_EVP_MD_CTX_DESTROY 1
+#define HAVE_EVP_MD_CTX_INIT 1
+#define HAVE_GETADDRINFO 1
+#define HAVE_GETHOSTBYNAME2 1
+#define HAVE_GETHOSTNAME 1
+#define HAVE_GETLOGIN 1
+#define HAVE_GETNAMEINFO 1
+#define HAVE_HMAC_CTX_CLEANUP 1
+#define HAVE_HMAC_CTX_INIT 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_NETINET_TCP_H 1
+#define HAVE_NETINET_UDP_H 1
+#define HAVE_OBJ_NAME_DO_ALL_SORTED 1
+#define HAVE_OPENLOG 1
+#define HAVE_OPENSSL_CLEANSE 1
+#define HAVE_OPENSSL_CONF_API_H 1
+#define HAVE_OPENSSL_ENGINE_H 1
+#define HAVE_OPENSSL_OCSP_H 1
+#define HAVE_OPENSSL_SSL_H 1
+#define HAVE_PEM_DEF_CALLBACK 1
+#define HAVE_PKCS5_PBKDF2_HMAC_SHA1 1
+#define HAVE_PTSNAME 1
+#define HAVE_RB_BLOCK_CALL 1
+#define HAVE_RB_STR_SET_LEN 1
+#define HAVE_RECVMSG 1
+#define HAVE_SENDMSG 1
+#define HAVE_SETLOGMASK 1
+#define HAVE_SETRESUID 1
+#define HAVE_SOCKADDR_STORAGE 1
+#define HAVE_SOCKET 1
+#define HAVE_SOCKETPAIR 1
+#define HAVE_SSL_SESSION_GET_ID 1
+#define HAVE_STRUCT_GROUP_GR_PASSWD 1
+#define HAVE_STRUCT_MSGHDR_MSG_CONTROL 1
+#define HAVE_STRUCT_PASSWD_PW_PASSWD 1
+#define HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY 1
+#define HAVE_ST_ENGINE 1
+#define HAVE_ST_FLAGS 1
+#define HAVE_ST_GR_PASSWD 1
+#define HAVE_ST_MSG_CONTROL 1
+#define HAVE_ST_PW_PASSWD 1
+#define HAVE_ST_SINGLE 1
+#define HAVE_SYSLOG_H 1
+#define HAVE_SYS_CDEFS_H 1
+#define HAVE_SYS_IOCTL_H 1
+#define HAVE_SYS_UN_H 1
+#define HAVE_TYPE_SOCKLEN_T 1
+#define HAVE_TYPE_UINT64_T 1
+#define HAVE_UNISTD_H 1
+#define HAVE_UTIL_H 1
+#define HAVE_VA_ARGS_MACRO 1
+#define HAVE_X509V3_EXT_NCONF_NID 1
+#define HAVE_X509V3_SET_NCONF 1
+#define HAVE_X509_ATTRIBUTE_SINGLE 1
+#define HAVE_X509_CRL_ADD0_REVOKED 1
+#define HAVE_X509_CRL_SET_ISSUER_NAME 1
+#define HAVE_X509_CRL_SET_VERSION 1
+#define HAVE_X509_CRL_SORT 1
+#define HAVE_ZLIB_H 1
+#define INET6 1
+#define NDEBUG 1
+#define RUBY_VERSION "1.9.1"
+
+#endif
rb_atomic_t size;
} signal_buff;
-#ifdef __dietlibc__
+#if defined(__dietlibc__) || defined(__BIONIC__)
#define sighandler_t sh_t
#endif