infraruby-java 0.0.0 → 3.6.0

data/ext/primitive/extconf.rb

@@ -0,0 +1,8 @@
+if RUBY_PLATFORM =~ /java/
+	File.write("Makefile", <<-END)
+install:
+	END
+else
+	require "mkmf"
+	create_makefile("primitive/primitive")
+end

data/ext/primitive/primitive.c

@@ -0,0 +1,4075 @@
+#include <ruby.h>
+#include <math.h>
+static VALUE r_Int32_0;
+static VALUE r_Int32_1;
+static VALUE r_Int32_M1;
+static int32_t
+__int32_div(int32_t x, int32_t y)
+{
+	if (y == 0)
+		rb_raise(rb_eZeroDivError, "divided by 0");
+	return x / y;
+}
+static int32_t
+__int32_mod(int32_t x, int32_t y)
+{
+	if (y == 0)
+		rb_raise(rb_eZeroDivError, "divided by 0");
+	return x % y;
+}
+static int32_t
+__int32_hash(int32_t value)
+{
+	return value;
+}
+static VALUE
+__int32_to_i(int32_t value)
+{
+	return LONG2NUM((long) value);
+}
+static VALUE
+__int32_to_f(int32_t value)
+{
+	return DBL2NUM((double) value);
+}
+static VALUE
+__int32_to_s(int32_t value)
+{
+	char s[11 + 1];
+	snprintf(s, 11 + 1, "%d", value);
+	return rb_usascii_str_new2(s);
+}
+static VALUE
+__int32_to_hex(int32_t value)
+{
+	char s[010 + 1];
+	int i = 010;
+	s[i] = 0;
+	while (1) {
+		i -= 1;
+		int c = (int32_t) value & 0x0F;
+		s[i] = (c < 10 ? c + 0x30 : c + 0x41 - 10);
+		if (i == 0)
+			break;
+		value >>= 4;
+	}
+	return rb_usascii_str_new2(s);
+}
+static VALUE
+__int32_chr(int32_t value)
+{
+	if (value < 0x00)
+		rb_raise(rb_eRangeError, "out of range");
+	if (value <= 0x7F) {
+		char s = (char) value;
+		return rb_usascii_str_new(&s, 1);
+	}
+	if (value <= 0xFF) {
+		char s = (char) value;
+		return rb_str_new(&s, 1);
+	}
+	rb_raise(rb_eRangeError, "out of range");
+}
+static int64_t
+__int64_div(int64_t x, int64_t y)
+{
+	if (y == 0)
+		rb_raise(rb_eZeroDivError, "divided by 0");
+	return x / y;
+}
+static int64_t
+__int64_mod(int64_t x, int64_t y)
+{
+	if (y == 0)
+		rb_raise(rb_eZeroDivError, "divided by 0");
+	return x % y;
+}
+static int32_t
+__int64_hash(int64_t value)
+{
+	return (int32_t) value ^ (int32_t) (value >> 32);
+}
+static VALUE
+__int64_to_i(int64_t value)
+{
+	return LONG2NUM((long) value);
+}
+static VALUE
+__int64_to_f(int64_t value)
+{
+	return DBL2NUM((double) value);
+}
+static VALUE
+__int64_to_s(int64_t value)
+{
+	char s[20 + 1];
+	snprintf(s, 20 + 1, "%ld", value);
+	return rb_usascii_str_new2(s);
+}
+static VALUE
+__int64_to_hex(int64_t value)
+{
+	char s[020 + 1];
+	int i = 020;
+	s[i] = 0;
+	while (1) {
+		i -= 1;
+		int c = (int32_t) value & 0x0F;
+		s[i] = (c < 10 ? c + 0x30 : c + 0x41 - 10);
+		if (i == 0)
+			break;
+		value >>= 4;
+	}
+	return rb_usascii_str_new2(s);
+}
+static float
+__float32_div(float x, float y)
+{
+	return x / y;
+}
+static float
+__float32_mod(float x, float y)
+{
+	return fmodf(x, y);
+}
+static int32_t
+__float32_hash(float value)
+{
+	union {
+		int32_t i32;
+		float f32;
+	} u;
+	u.f32 = value;
+	return __int32_hash(u.i32);
+}
+static VALUE
+__float32_to_i(float value)
+{
+	if (isnan(value))
+		rb_raise(rb_eFloatDomainError, "NaN");
+	if (isinf(value))
+		rb_raise(rb_eFloatDomainError, value < 0 ? "-Infinity" : "Infinity");
+	if (value < FIXNUM_MIN || value >= FIXNUM_MAX + 1)
+		return rb_dbl2big((double) value);
+	return LONG2FIX((long) value);
+}
+static VALUE
+__float32_to_f(float value)
+{
+	return DBL2NUM((double) value);
+}
+static VALUE
+__float32_to_s(float value)
+{
+	if (isnan(value))
+		return rb_usascii_str_new2("NaN");
+	if (value == INFINITY)
+		return rb_usascii_str_new2("Infinity");
+	if (value == -INFINITY)
+		return rb_usascii_str_new2("-Infinity");
+	char s[15 + 1];
+	snprintf(s, 15 + 1, "%.9G", value);
+	return rb_usascii_str_new2(s);
+}
+static double
+__float64_div(double x, double y)
+{
+	return x / y;
+}
+static double
+__float64_mod(double x, double y)
+{
+	return fmod(x, y);
+}
+static int32_t
+__float64_hash(double value)
+{
+	union {
+		int64_t i64;
+		double f64;
+	} u;
+	u.f64 = value;
+	return __int64_hash(u.i64);
+}
+static VALUE
+__float64_to_i(double value)
+{
+	if (isnan(value))
+		rb_raise(rb_eFloatDomainError, "NaN");
+	if (isinf(value))
+		rb_raise(rb_eFloatDomainError, value < 0 ? "-Infinity" : "Infinity");
+	if (value < FIXNUM_MIN || value >= FIXNUM_MAX + 1)
+		return rb_dbl2big(value);
+	return LONG2FIX((long) value);
+}
+static VALUE
+__float64_to_f(double value)
+{
+	return DBL2NUM((double) value);
+}
+static VALUE
+__float64_to_s(double value)
+{
+	if (isnan(value))
+		return rb_usascii_str_new2("NaN");
+	if (value == INFINITY)
+		return rb_usascii_str_new2("Infinity");
+	if (value == -INFINITY)
+		return rb_usascii_str_new2("-Infinity");
+	char s[24 + 1];
+	snprintf(s, 24 + 1, "%.17G", value);
+	return rb_usascii_str_new2(s);
+}
+struct Byte {
+	int8_t value;
+};
+typedef struct Byte Byte;
+static VALUE r_Byte;
+struct Char {
+	uint16_t value;
+};
+typedef struct Char Char;
+static VALUE r_Char;
+struct Int16 {
+	int16_t value;
+};
+typedef struct Int16 Int16;
+static VALUE r_Int16;
+struct Int32 {
+	int32_t value;
+};
+typedef struct Int32 Int32;
+static VALUE r_Int32;
+struct Int64 {
+	int64_t value;
+};
+typedef struct Int64 Int64;
+static VALUE r_Int64;
+struct Float32 {
+	float value;
+};
+typedef struct Float32 Float32;
+static VALUE r_Float32;
+struct Float64 {
+	double value;
+};
+typedef struct Float64 Float64;
+static VALUE r_Float64;
+static VALUE
+__allocate_Byte(int8_t value)
+{
+	Byte *p = ALLOC(Byte);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->value = value;
+	return Data_Wrap_Struct(r_Byte, NULL, NULL, p);
+}
+static VALUE
+__allocate_Char(uint16_t value)
+{
+	Char *p = ALLOC(Char);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->value = value;
+	return Data_Wrap_Struct(r_Char, NULL, NULL, p);
+}
+static VALUE
+__allocate_Int16(int16_t value)
+{
+	Int16 *p = ALLOC(Int16);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->value = value;
+	return Data_Wrap_Struct(r_Int16, NULL, NULL, p);
+}
+static VALUE
+__allocate_Int32(int32_t value)
+{
+	Int32 *p = ALLOC(Int32);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->value = value;
+	return Data_Wrap_Struct(r_Int32, NULL, NULL, p);
+}
+static VALUE
+__allocate_Int64(int64_t value)
+{
+	Int64 *p = ALLOC(Int64);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->value = value;
+	return Data_Wrap_Struct(r_Int64, NULL, NULL, p);
+}
+static VALUE
+__allocate_Float32(float value)
+{
+	Float32 *p = ALLOC(Float32);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->value = value;
+	return Data_Wrap_Struct(r_Float32, NULL, NULL, p);
+}
+static VALUE
+__allocate_Float64(double value)
+{
+	Float64 *p = ALLOC(Float64);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->value = value;
+	return Data_Wrap_Struct(r_Float64, NULL, NULL, p);
+}
+static VALUE r_Java;
+static ID NEW_ID;
+static ID INNER_ID;
+static ID OUTER_ID;
+static ID COPY_ID;
+struct ObjectArray {
+	int32_t length;
+	VALUE data[];
+};
+typedef struct ObjectArray ObjectArray;
+static VALUE r_ObjectArray;
+struct BooleanArray {
+	int32_t length;
+	int8_t data[];
+};
+typedef struct BooleanArray BooleanArray;
+static VALUE r_BooleanArray;
+struct ByteArray {
+	int32_t length;
+	int8_t data[];
+};
+typedef struct ByteArray ByteArray;
+static VALUE r_ByteArray;
+struct CharArray {
+	int32_t length;
+	uint16_t data[];
+};
+typedef struct CharArray CharArray;
+static VALUE r_CharArray;
+struct Int16Array {
+	int32_t length;
+	int16_t data[];
+};
+typedef struct Int16Array Int16Array;
+static VALUE r_Int16Array;
+struct Int32Array {
+	int32_t length;
+	int32_t data[];
+};
+typedef struct Int32Array Int32Array;
+static VALUE r_Int32Array;
+struct Int64Array {
+	int32_t length;
+	int64_t data[];
+};
+typedef struct Int64Array Int64Array;
+static VALUE r_Int64Array;
+struct Float32Array {
+	int32_t length;
+	float data[];
+};
+typedef struct Float32Array Float32Array;
+static VALUE r_Float32Array;
+struct Float64Array {
+	int32_t length;
+	double data[];
+};
+typedef struct Float64Array Float64Array;
+static VALUE r_Float64Array;
+static void
+__mark_ObjectArray(void *__p)
+{
+	ObjectArray *p = __p;
+	int32_t i;
+	for (i = 0; i < p->length; i += 1) {
+		VALUE e = p->data[i];
+		rb_gc_mark(e);
+	}
+	return;
+}
+static void
+__free_ObjectArray(void *__p)
+{
+	ObjectArray *p = __p;
+	xfree(p);
+	return;
+}
+static VALUE
+__allocate_ObjectArray(VALUE self, int32_t n)
+{
+	ObjectArray *p = xmalloc(sizeof(ObjectArray) + sizeof(VALUE) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = Qnil;
+	return Data_Wrap_Struct(self, __mark_ObjectArray, __free_ObjectArray, p);
+}
+static VALUE
+__allocate_BooleanArray(VALUE self, int32_t n)
+{
+	BooleanArray *p = xmalloc(sizeof(BooleanArray) + sizeof(int8_t) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = 0;
+	return Data_Wrap_Struct(self, NULL, NULL, p);
+}
+static VALUE
+__allocate_ByteArray(VALUE self, int32_t n)
+{
+	ByteArray *p = xmalloc(sizeof(ByteArray) + sizeof(int8_t) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = 0;
+	return Data_Wrap_Struct(self, NULL, NULL, p);
+}
+static VALUE
+__allocate_CharArray(VALUE self, int32_t n)
+{
+	CharArray *p = xmalloc(sizeof(CharArray) + sizeof(uint16_t) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = 0;
+	return Data_Wrap_Struct(self, NULL, NULL, p);
+}
+static VALUE
+__allocate_Int16Array(VALUE self, int32_t n)
+{
+	Int16Array *p = xmalloc(sizeof(Int16Array) + sizeof(int16_t) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = 0;
+	return Data_Wrap_Struct(self, NULL, NULL, p);
+}
+static VALUE
+__allocate_Int32Array(VALUE self, int32_t n)
+{
+	Int32Array *p = xmalloc(sizeof(Int32Array) + sizeof(int32_t) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = 0;
+	return Data_Wrap_Struct(self, NULL, NULL, p);
+}
+static VALUE
+__allocate_Int64Array(VALUE self, int32_t n)
+{
+	Int64Array *p = xmalloc(sizeof(Int64Array) + sizeof(int64_t) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = 0;
+	return Data_Wrap_Struct(self, NULL, NULL, p);
+}
+static VALUE
+__allocate_Float32Array(VALUE self, int32_t n)
+{
+	Float32Array *p = xmalloc(sizeof(Float32Array) + sizeof(float) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = 0;
+	return Data_Wrap_Struct(self, NULL, NULL, p);
+}
+static VALUE
+__allocate_Float64Array(VALUE self, int32_t n)
+{
+	Float64Array *p = xmalloc(sizeof(Float64Array) + sizeof(double) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = 0;
+	return Data_Wrap_Struct(self, NULL, NULL, p);
+}
+static int32_t
+__Int32_value(VALUE o)
+{
+	if (TYPE(o) != T_DATA || RBASIC(o)->klass != r_Int32)
+		rb_raise(rb_eTypeError, "expected Int32");
+	Int32 *p;
+	Data_Get_Struct(o, Int32, p);
+	return p->value;
+}
+static VALUE
+r_ObjectArray_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_ObjectArray(self, __n);
+}
+static VALUE
+r_BooleanArray_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_BooleanArray(self, __n);
+}
+static VALUE
+r_ByteArray_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_ByteArray(self, __n);
+}
+static VALUE
+r_CharArray_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_CharArray(self, __n);
+}
+static VALUE
+r_Int16Array_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_Int16Array(self, __n);
+}
+static VALUE
+r_Int32Array_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_Int32Array(self, __n);
+}
+static VALUE
+r_Int64Array_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_Int64Array(self, __n);
+}
+static VALUE
+r_Float32Array_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_Float32Array(self, __n);
+}
+static VALUE
+r_Float64Array_new(VALUE self, VALUE n)
+{
+	int32_t __n = __Int32_value(n);
+	return __allocate_Float64Array(self, __n);
+}
+static VALUE
+__new_Array(VALUE klass, VALUE *data, int b, int c)
+{
+	VALUE o = data[b];
+	if (b + 1 == c)
+		return rb_funcall(klass, NEW_ID, 1, o);
+	int32_t n = __Int32_value(o);
+	VALUE r = __allocate_ObjectArray(klass, n);
+	ObjectArray *p;
+	Data_Get_Struct(r, ObjectArray, p);
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = __new_Array(rb_ivar_get(klass, INNER_ID), data, b + 1, c);
+	return r;
+}
+struct ArrayFactory {
+	VALUE klass;
+	int32_t length;
+	VALUE data[];
+};
+typedef struct ArrayFactory ArrayFactory;
+static VALUE r_ArrayFactory;
+struct ArrayFactoryFactory {
+	VALUE klass;
+};
+typedef struct ArrayFactoryFactory ArrayFactoryFactory;
+static VALUE r_ArrayFactoryFactory;
+static VALUE r_BOOLEAN_ARRAY_FACTORY_FACTORY;
+static VALUE r_BYTE_ARRAY_FACTORY_FACTORY;
+static VALUE r_CHAR_ARRAY_FACTORY_FACTORY;
+static VALUE r_INT16_ARRAY_FACTORY_FACTORY;
+static VALUE r_INT32_ARRAY_FACTORY_FACTORY;
+static VALUE r_INT64_ARRAY_FACTORY_FACTORY;
+static VALUE r_FLOAT32_ARRAY_FACTORY_FACTORY;
+static VALUE r_FLOAT64_ARRAY_FACTORY_FACTORY;
+static VALUE
+r_Java_boolean(VALUE self)
+{
+	return r_BOOLEAN_ARRAY_FACTORY_FACTORY;
+}
+static VALUE
+r_Java_byte(VALUE self)
+{
+	return r_BYTE_ARRAY_FACTORY_FACTORY;
+}
+static VALUE
+r_Java_char(VALUE self)
+{
+	return r_CHAR_ARRAY_FACTORY_FACTORY;
+}
+static VALUE
+r_Java_int16(VALUE self)
+{
+	return r_INT16_ARRAY_FACTORY_FACTORY;
+}
+static VALUE
+r_Java_int32(VALUE self)
+{
+	return r_INT32_ARRAY_FACTORY_FACTORY;
+}
+static VALUE
+r_Java_int64(VALUE self)
+{
+	return r_INT64_ARRAY_FACTORY_FACTORY;
+}
+static VALUE
+r_Java_float32(VALUE self)
+{
+	return r_FLOAT32_ARRAY_FACTORY_FACTORY;
+}
+static VALUE
+r_Java_float64(VALUE self)
+{
+	return r_FLOAT64_ARRAY_FACTORY_FACTORY;
+}
+static VALUE r_Integer_x8000000000000000;
+static VALUE r_Integer_xFFFFFFFFFFFFFFFF;
+static VALUE r_Integer_xM8000000000000000;
+static int64_t
+__bignum_to_int64(VALUE o)
+{
+	o = rb_big_plus(r_Integer_x8000000000000000, o);
+	o = rb_big_and(r_Integer_xFFFFFFFFFFFFFFFF, o);
+	o = rb_big_plus(r_Integer_xM8000000000000000, o);
+	return NUM2LONG(o);
+}
+static int32_t
+__object_i32(VALUE o)
+{
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_FIXNUM:
+		return (int32_t) FIX2LONG(o);
+	case T_BIGNUM:
+		return (int32_t) __bignum_to_int64(o);
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Byte) {
+			Byte *p;
+			Data_Get_Struct(o, Byte, p);
+			return (int32_t) p->value;
+		}
+		if (klass == r_Char) {
+			Char *p;
+			Data_Get_Struct(o, Char, p);
+			return (int32_t) p->value;
+		}
+		if (klass == r_Int16) {
+			Int16 *p;
+			Data_Get_Struct(o, Int16, p);
+			return (int32_t) p->value;
+		}
+		if (klass == r_Int32) {
+			Int32 *p;
+			Data_Get_Struct(o, Int32, p);
+			return (int32_t) p->value;
+		}
+	}
+	rb_raise(rb_eTypeError, "expected int32");
+}
+static int64_t
+__object_i64(VALUE o)
+{
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_FIXNUM:
+		return (int64_t) FIX2LONG(o);
+	case T_BIGNUM:
+		return (int64_t) __bignum_to_int64(o);
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Int64) {
+			Int64 *p;
+			Data_Get_Struct(o, Int64, p);
+			return (int64_t) p->value;
+		}
+	}
+	rb_raise(rb_eTypeError, "expected int64");
+}
+static float
+__object_f32(VALUE o)
+{
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_FIXNUM:
+		return (float) FIX2LONG(o);
+	case T_BIGNUM:
+		return (float) NUM2DBL(o);
+	case T_FLOAT:
+		return (float) NUM2DBL(o);
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Float32) {
+			Float32 *p;
+			Data_Get_Struct(o, Float32, p);
+			return (float) p->value;
+		}
+	}
+	rb_raise(rb_eTypeError, "expected float32");
+}
+static double
+__object_f64(VALUE o)
+{
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_FIXNUM:
+		return (double) FIX2LONG(o);
+	case T_BIGNUM:
+		return (double) NUM2DBL(o);
+	case T_FLOAT:
+		return (double) NUM2DBL(o);
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Float64) {
+			Float64 *p;
+			Data_Get_Struct(o, Float64, p);
+			return (double) p->value;
+		}
+	}
+	rb_raise(rb_eTypeError, "expected float64");
+}
+static int8_t
+__object_to_boolean(VALUE o)
+{
+	switch (TYPE(o)) {
+	case T_TRUE:
+		return Qtrue;
+	case T_FALSE:
+		return Qfalse;
+	}
+	rb_raise(rb_eTypeError, "expected boolean");
+}
+static int32_t
+__assert_bounds(VALUE i, int32_t n)
+{
+	Check_Type(i, T_FIXNUM);
+	long __i = FIX2LONG(i);
+	if (__i < 0 || __i >= n)
+		rb_raise(rb_eArgError, "index out of bounds");
+	return (int32_t) __i;
+}
+static int32_t
+__assert_nat32(VALUE i)
+{
+	Check_Type(i, T_FIXNUM);
+	long __i = FIX2LONG(i);
+	if (__i < 0 || __i > 0x7FFFFFFFL)
+		rb_raise(rb_eArgError, "out of range");
+	return (int32_t) __i;
+}
+static VALUE
+r_Byte_new(VALUE self, VALUE o)
+{
+	int32_t v = __object_i32(o);
+	return __allocate_Byte((int8_t) v);
+}
+static VALUE
+r_Byte_is_eql(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Byte) {
+			Byte *op;
+			Data_Get_Struct(o, Byte, op);
+			return p->value == op->value ? Qtrue : Qfalse;
+		}
+	}
+	return Qfalse;
+}
+static VALUE
+r_Byte_hash(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return LONG2NUM((long) __int32_hash(value));
+}
+static VALUE
+r_Byte_to_byte(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Byte((int8_t) value);
+}
+static VALUE
+r_Byte_to_char(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Char((uint16_t) value);
+}
+static VALUE
+r_Byte_to_int16(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Int16((int16_t) value);
+}
+static VALUE
+r_Byte_to_int32(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Int32((int32_t) value);
+}
+static VALUE
+r_Byte_to_int64(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Int64((int64_t) value);
+}
+static VALUE
+r_Byte_to_float32(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Float32((float) value);
+}
+static VALUE
+r_Byte_to_float64(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Float64((double) value);
+}
+static VALUE
+r_Byte_to_i(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __int32_to_i(value);
+}
+static VALUE
+r_Byte_to_f(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __int32_to_f(value);
+}
+static VALUE
+r_Byte_to_s(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __int32_to_s(value);
+}
+static VALUE
+r_Byte_eq(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value == v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Byte_ne(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value != v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Byte_pos(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Int32(+value);
+}
+static VALUE
+r_Byte_neg(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Int32(-value);
+}
+static VALUE
+r_Byte_mul(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value * v);
+}
+static VALUE
+r_Byte_div(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(__int32_div(value, v));
+}
+static VALUE
+r_Byte_mod(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(__int32_mod(value, v));
+}
+static VALUE
+r_Byte_add(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value + v);
+}
+static VALUE
+r_Byte_sub(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value - v);
+}
+static VALUE
+r_Byte_cmp(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	if (value < v)
+		return r_Int32_M1;
+	if (value > v)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Byte_lt(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value < v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Byte_le(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value <= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Byte_ge(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value >= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Byte_gt(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value > v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Byte_inv(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return __allocate_Int32(~value);
+}
+static VALUE
+r_Byte_shl(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value << v);
+}
+static VALUE
+r_Byte_shr(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value >> v);
+}
+static VALUE
+r_Byte_ushr(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	uint32_t uvalue = (uint32_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32((int32_t) (uvalue >> v));
+}
+static VALUE
+r_Byte_and(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value & v);
+}
+static VALUE
+r_Byte_xor(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value ^ v);
+}
+static VALUE
+r_Byte_or(VALUE self, VALUE o)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value | v);
+}
+static VALUE
+r_Byte_is_zero(VALUE self)
+{
+	Byte *p;
+	Data_Get_Struct(self, Byte, p);
+	int32_t value = p->value;
+	return value == 0 ? Qtrue : Qfalse;
+}
+static VALUE
+r_Char_new(VALUE self, VALUE o)
+{
+	int32_t v = __object_i32(o);
+	return __allocate_Char((uint16_t) v);
+}
+static VALUE
+r_Char_is_eql(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Char) {
+			Char *op;
+			Data_Get_Struct(o, Char, op);
+			return p->value == op->value ? Qtrue : Qfalse;
+		}
+	}
+	return Qfalse;
+}
+static VALUE
+r_Char_hash(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return LONG2NUM((long) __int32_hash(value));
+}
+static VALUE
+r_Char_to_byte(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Byte((int8_t) value);
+}
+static VALUE
+r_Char_to_char(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Char((uint16_t) value);
+}
+static VALUE
+r_Char_to_int16(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Int16((int16_t) value);
+}
+static VALUE
+r_Char_to_int32(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Int32((int32_t) value);
+}
+static VALUE
+r_Char_to_int64(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Int64((int64_t) value);
+}
+static VALUE
+r_Char_to_float32(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Float32((float) value);
+}
+static VALUE
+r_Char_to_float64(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Float64((double) value);
+}
+static VALUE
+r_Char_to_i(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __int32_to_i(value);
+}
+static VALUE
+r_Char_to_f(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __int32_to_f(value);
+}
+static VALUE
+r_Char_to_s(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __int32_to_s(value);
+}
+static VALUE
+r_Char_eq(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value == v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Char_ne(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value != v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Char_pos(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Int32(+value);
+}
+static VALUE
+r_Char_neg(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Int32(-value);
+}
+static VALUE
+r_Char_mul(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value * v);
+}
+static VALUE
+r_Char_div(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(__int32_div(value, v));
+}
+static VALUE
+r_Char_mod(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(__int32_mod(value, v));
+}
+static VALUE
+r_Char_add(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value + v);
+}
+static VALUE
+r_Char_sub(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value - v);
+}
+static VALUE
+r_Char_cmp(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	if (value < v)
+		return r_Int32_M1;
+	if (value > v)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Char_lt(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value < v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Char_le(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value <= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Char_ge(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value >= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Char_gt(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value > v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Char_inv(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return __allocate_Int32(~value);
+}
+static VALUE
+r_Char_shl(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value << v);
+}
+static VALUE
+r_Char_shr(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value >> v);
+}
+static VALUE
+r_Char_ushr(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	uint32_t uvalue = (uint32_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32((int32_t) (uvalue >> v));
+}
+static VALUE
+r_Char_and(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value & v);
+}
+static VALUE
+r_Char_xor(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value ^ v);
+}
+static VALUE
+r_Char_or(VALUE self, VALUE o)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value | v);
+}
+static VALUE
+r_Char_is_zero(VALUE self)
+{
+	Char *p;
+	Data_Get_Struct(self, Char, p);
+	int32_t value = p->value;
+	return value == 0 ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int16_new(VALUE self, VALUE o)
+{
+	int32_t v = __object_i32(o);
+	return __allocate_Int16((int16_t) v);
+}
+static VALUE
+r_Int16_is_eql(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Int16) {
+			Int16 *op;
+			Data_Get_Struct(o, Int16, op);
+			return p->value == op->value ? Qtrue : Qfalse;
+		}
+	}
+	return Qfalse;
+}
+static VALUE
+r_Int16_hash(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return LONG2NUM((long) __int32_hash(value));
+}
+static VALUE
+r_Int16_to_byte(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Byte((int8_t) value);
+}
+static VALUE
+r_Int16_to_char(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Char((uint16_t) value);
+}
+static VALUE
+r_Int16_to_int16(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Int16((int16_t) value);
+}
+static VALUE
+r_Int16_to_int32(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Int32((int32_t) value);
+}
+static VALUE
+r_Int16_to_int64(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Int64((int64_t) value);
+}
+static VALUE
+r_Int16_to_float32(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Float32((float) value);
+}
+static VALUE
+r_Int16_to_float64(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Float64((double) value);
+}
+static VALUE
+r_Int16_to_i(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __int32_to_i(value);
+}
+static VALUE
+r_Int16_to_f(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __int32_to_f(value);
+}
+static VALUE
+r_Int16_to_s(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __int32_to_s(value);
+}
+static VALUE
+r_Int16_eq(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value == v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int16_ne(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value != v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int16_pos(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Int32(+value);
+}
+static VALUE
+r_Int16_neg(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Int32(-value);
+}
+static VALUE
+r_Int16_mul(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value * v);
+}
+static VALUE
+r_Int16_div(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(__int32_div(value, v));
+}
+static VALUE
+r_Int16_mod(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(__int32_mod(value, v));
+}
+static VALUE
+r_Int16_add(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value + v);
+}
+static VALUE
+r_Int16_sub(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value - v);
+}
+static VALUE
+r_Int16_cmp(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	if (value < v)
+		return r_Int32_M1;
+	if (value > v)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Int16_lt(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value < v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int16_le(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value <= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int16_ge(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value >= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int16_gt(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value > v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int16_inv(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return __allocate_Int32(~value);
+}
+static VALUE
+r_Int16_shl(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value << v);
+}
+static VALUE
+r_Int16_shr(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value >> v);
+}
+static VALUE
+r_Int16_ushr(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	uint32_t uvalue = (uint32_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32((int32_t) (uvalue >> v));
+}
+static VALUE
+r_Int16_and(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value & v);
+}
+static VALUE
+r_Int16_xor(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value ^ v);
+}
+static VALUE
+r_Int16_or(VALUE self, VALUE o)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value | v);
+}
+static VALUE
+r_Int16_is_zero(VALUE self)
+{
+	Int16 *p;
+	Data_Get_Struct(self, Int16, p);
+	int32_t value = p->value;
+	return value == 0 ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int32_new(VALUE self, VALUE o)
+{
+	int32_t v = __object_i32(o);
+	return __allocate_Int32((int32_t) v);
+}
+static VALUE
+r_Int32_is_eql(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Int32) {
+			Int32 *op;
+			Data_Get_Struct(o, Int32, op);
+			return p->value == op->value ? Qtrue : Qfalse;
+		}
+	}
+	return Qfalse;
+}
+static VALUE
+r_Int32_hash(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return LONG2NUM((long) __int32_hash(value));
+}
+static VALUE
+r_Int32_to_byte(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Byte((int8_t) value);
+}
+static VALUE
+r_Int32_to_char(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Char((uint16_t) value);
+}
+static VALUE
+r_Int32_to_int16(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Int16((int16_t) value);
+}
+static VALUE
+r_Int32_to_int32(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Int32((int32_t) value);
+}
+static VALUE
+r_Int32_to_int64(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Int64((int64_t) value);
+}
+static VALUE
+r_Int32_to_float32(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Float32((float) value);
+}
+static VALUE
+r_Int32_to_float64(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Float64((double) value);
+}
+static VALUE
+r_Int32_to_i(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __int32_to_i(value);
+}
+static VALUE
+r_Int32_to_f(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __int32_to_f(value);
+}
+static VALUE
+r_Int32_to_s(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __int32_to_s(value);
+}
+static VALUE
+r_Int32_eq(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value == v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int32_ne(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value != v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int32_pos(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Int32(+value);
+}
+static VALUE
+r_Int32_neg(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Int32(-value);
+}
+static VALUE
+r_Int32_mul(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value * v);
+}
+static VALUE
+r_Int32_div(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(__int32_div(value, v));
+}
+static VALUE
+r_Int32_mod(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(__int32_mod(value, v));
+}
+static VALUE
+r_Int32_add(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value + v);
+}
+static VALUE
+r_Int32_sub(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value - v);
+}
+static VALUE
+r_Int32_cmp(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	if (value < v)
+		return r_Int32_M1;
+	if (value > v)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Int32_lt(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value < v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int32_le(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value <= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int32_ge(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value >= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int32_gt(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return value > v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int32_inv(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Int32(~value);
+}
+static VALUE
+r_Int32_shl(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value << v);
+}
+static VALUE
+r_Int32_shr(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value >> v);
+}
+static VALUE
+r_Int32_ushr(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	uint32_t uvalue = (uint32_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32((int32_t) (uvalue >> v));
+}
+static VALUE
+r_Int32_and(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value & v);
+}
+static VALUE
+r_Int32_xor(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value ^ v);
+}
+static VALUE
+r_Int32_or(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32(value | v);
+}
+static VALUE
+r_Int32_is_zero(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return value == 0 ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int32_bang_to_int32(VALUE self)
+{
+	return self;
+}
+static VALUE
+r_Int32_bang_to_int64(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __allocate_Int64((int64_t) value);
+}
+static VALUE
+r_Int32_to_fixnum(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return LONG2NUM((long) value);
+}
+static VALUE
+r_Int32_to_hex(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __int32_to_hex(value);
+}
+static VALUE
+r_Int32_chr(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	return __int32_chr(value);
+}
+static VALUE
+r_Int32_rol(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	uint32_t uvalue = (uint32_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32((int32_t) (uvalue << v | uvalue >> (32 - v)));
+}
+static VALUE
+r_Int32_ror(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	uint32_t uvalue = (uint32_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int32((int32_t) (uvalue >> v | uvalue << (32 - v)));
+}
+static VALUE
+r_Int32_count(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t c = 0;
+	while (value != 0) {
+		value &= value - 1;
+		c += 1;
+	}
+	return __allocate_Int32(c);
+}
+static VALUE
+r_Int32_signum(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	if (value < 0)
+		return r_Int32_M1;
+	if (value > 0)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Int32_times(VALUE self)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t value = p->value;
+	int32_t i = 0;
+	while (i < value) {
+		rb_yield(__allocate_Int32(i));
+		i += 1;
+	}
+	return Qnil;
+}
+static VALUE
+r_Int32_upto(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t i = p->value;
+	int32_t v = __object_i32(o);
+	if (i <= v) {
+		while (1) {
+			rb_yield(__allocate_Int32(i));
+			if (i == v)
+				break;
+			i += 1;
+		}
+	}
+	return Qnil;
+}
+static VALUE
+r_Int32_downto(VALUE self, VALUE o)
+{
+	Int32 *p;
+	Data_Get_Struct(self, Int32, p);
+	int32_t i = p->value;
+	int32_t v = __object_i32(o);
+	if (i >= v) {
+		while (1) {
+			rb_yield(__allocate_Int32(i));
+			if (i == v)
+				break;
+			i -= 1;
+		}
+	}
+	return Qnil;
+}
+static VALUE
+r_Int64_new(VALUE self, VALUE o)
+{
+	int64_t v = __object_i64(o);
+	return __allocate_Int64((int64_t) v);
+}
+static VALUE
+r_Int64_is_eql(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Int64) {
+			Int64 *op;
+			Data_Get_Struct(o, Int64, op);
+			return p->value == op->value ? Qtrue : Qfalse;
+		}
+	}
+	return Qfalse;
+}
+static VALUE
+r_Int64_hash(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return LONG2NUM((long) __int64_hash(value));
+}
+static VALUE
+r_Int64_to_byte(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Byte((int8_t) value);
+}
+static VALUE
+r_Int64_to_char(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Char((uint16_t) value);
+}
+static VALUE
+r_Int64_to_int16(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Int16((int16_t) value);
+}
+static VALUE
+r_Int64_to_int32(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Int32((int32_t) value);
+}
+static VALUE
+r_Int64_to_int64(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Int64((int64_t) value);
+}
+static VALUE
+r_Int64_to_float32(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Float32((float) value);
+}
+static VALUE
+r_Int64_to_float64(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Float64((double) value);
+}
+static VALUE
+r_Int64_to_i(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __int64_to_i(value);
+}
+static VALUE
+r_Int64_to_f(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __int64_to_f(value);
+}
+static VALUE
+r_Int64_to_s(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __int64_to_s(value);
+}
+static VALUE
+r_Int64_eq(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return value == v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int64_ne(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return value != v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int64_pos(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Int64(+value);
+}
+static VALUE
+r_Int64_neg(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Int64(-value);
+}
+static VALUE
+r_Int64_mul(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return __allocate_Int64(value * v);
+}
+static VALUE
+r_Int64_div(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return __allocate_Int64(__int64_div(value, v));
+}
+static VALUE
+r_Int64_mod(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return __allocate_Int64(__int64_mod(value, v));
+}
+static VALUE
+r_Int64_add(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return __allocate_Int64(value + v);
+}
+static VALUE
+r_Int64_sub(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return __allocate_Int64(value - v);
+}
+static VALUE
+r_Int64_cmp(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	if (value < v)
+		return r_Int32_M1;
+	if (value > v)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Int64_lt(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return value < v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int64_le(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return value <= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int64_ge(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return value >= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int64_gt(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return value > v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int64_inv(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __allocate_Int64(~value);
+}
+static VALUE
+r_Int64_shl(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int64(value << v);
+}
+static VALUE
+r_Int64_shr(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int64(value >> v);
+}
+static VALUE
+r_Int64_ushr(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	uint64_t uvalue = (uint64_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int64((int64_t) (uvalue >> v));
+}
+static VALUE
+r_Int64_and(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return __allocate_Int64(value & v);
+}
+static VALUE
+r_Int64_xor(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return __allocate_Int64(value ^ v);
+}
+static VALUE
+r_Int64_or(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t v = __object_i64(o);
+	return __allocate_Int64(value | v);
+}
+static VALUE
+r_Int64_is_zero(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return value == 0 ? Qtrue : Qfalse;
+}
+static VALUE
+r_Int64_bang_to_int32(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	if (value < -0x80000000L || value > 0x7FFFFFFFL)
+		rb_raise(rb_eRangeError, "int64 too big to convert to int32");
+	return __allocate_Int32((int32_t) value);
+}
+static VALUE
+r_Int64_bang_to_int64(VALUE self)
+{
+	return self;
+}
+static VALUE
+r_Int64_to_fixnum(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return LONG2NUM((long) value);
+}
+static VALUE
+r_Int64_to_hex(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	return __int64_to_hex(value);
+}
+static VALUE
+r_Int64_rol(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	uint64_t uvalue = (uint64_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int64((int64_t) (uvalue << v | uvalue >> (64 - v)));
+}
+static VALUE
+r_Int64_ror(VALUE self, VALUE o)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	uint64_t uvalue = (uint64_t) p->value;
+	int32_t v = __object_i32(o);
+	return __allocate_Int64((int64_t) (uvalue >> v | uvalue << (64 - v)));
+}
+static VALUE
+r_Int64_count(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int32_t c = 0;
+	while (value != 0) {
+		value &= value - 1;
+		c += 1;
+	}
+	return __allocate_Int32(c);
+}
+static VALUE
+r_Int64_signum(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	if (value < 0)
+		return r_Int32_M1;
+	if (value > 0)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Int64_times(VALUE self)
+{
+	Int64 *p;
+	Data_Get_Struct(self, Int64, p);
+	int64_t value = p->value;
+	int64_t i = 0;
+	while (i < value) {
+		rb_yield(__allocate_Int64(i));
+		i += 1;
+	}
+	return Qnil;
+}
+static VALUE
+r_Float32_new(VALUE self, VALUE o)
+{
+	float v = __object_f32(o);
+	return __allocate_Float32((float) v);
+}
+static VALUE
+r_Float32_is_eql(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Float32) {
+			Float32 *op;
+			Data_Get_Struct(o, Float32, op);
+			return p->value == op->value ? Qtrue : Qfalse;
+		}
+	}
+	return Qfalse;
+}
+static VALUE
+r_Float32_hash(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return LONG2NUM((long) __float32_hash(value));
+}
+static VALUE
+r_Float32_to_byte(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Byte((int8_t) value);
+}
+static VALUE
+r_Float32_to_char(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Char((uint16_t) value);
+}
+static VALUE
+r_Float32_to_int16(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Int16((int16_t) value);
+}
+static VALUE
+r_Float32_to_int32(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Int32((int32_t) value);
+}
+static VALUE
+r_Float32_to_int64(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Int64((int64_t) value);
+}
+static VALUE
+r_Float32_to_float32(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Float32((float) value);
+}
+static VALUE
+r_Float32_to_float64(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Float64((double) value);
+}
+static VALUE
+r_Float32_to_i(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __float32_to_i(value);
+}
+static VALUE
+r_Float32_to_f(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __float32_to_f(value);
+}
+static VALUE
+r_Float32_to_s(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __float32_to_s(value);
+}
+static VALUE
+r_Float32_eq(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return value == v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_ne(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return value != v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_pos(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Float32(+value);
+}
+static VALUE
+r_Float32_neg(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return __allocate_Float32(-value);
+}
+static VALUE
+r_Float32_mul(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return __allocate_Float32(value * v);
+}
+static VALUE
+r_Float32_div(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return __allocate_Float32(__float32_div(value, v));
+}
+static VALUE
+r_Float32_mod(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return __allocate_Float32(__float32_mod(value, v));
+}
+static VALUE
+r_Float32_add(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return __allocate_Float32(value + v);
+}
+static VALUE
+r_Float32_sub(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return __allocate_Float32(value - v);
+}
+static VALUE
+r_Float32_cmp(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	if (value < v)
+		return r_Int32_M1;
+	if (value > v)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Float32_lt(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return value < v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_le(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return value <= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_ge(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return value >= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_gt(VALUE self, VALUE o)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	float v = __object_f32(o);
+	return value > v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_is_zero(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return value == 0 ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_is_nan(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return isnan(value) ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_is_infinite(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return isinf(value) ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float32_is_finite(VALUE self)
+{
+	Float32 *p;
+	Data_Get_Struct(self, Float32, p);
+	float value = p->value;
+	return !isnan(value) && !isinf(value) ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_new(VALUE self, VALUE o)
+{
+	double v = __object_f64(o);
+	return __allocate_Float64((double) v);
+}
+static VALUE
+r_Float64_is_eql(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	VALUE klass;
+	switch (TYPE(o)) {
+	case T_DATA:
+		klass = RBASIC(o)->klass;
+		if (klass == r_Float64) {
+			Float64 *op;
+			Data_Get_Struct(o, Float64, op);
+			return p->value == op->value ? Qtrue : Qfalse;
+		}
+	}
+	return Qfalse;
+}
+static VALUE
+r_Float64_hash(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return LONG2NUM((long) __float64_hash(value));
+}
+static VALUE
+r_Float64_to_byte(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Byte((int8_t) value);
+}
+static VALUE
+r_Float64_to_char(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Char((uint16_t) value);
+}
+static VALUE
+r_Float64_to_int16(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Int16((int16_t) value);
+}
+static VALUE
+r_Float64_to_int32(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Int32((int32_t) value);
+}
+static VALUE
+r_Float64_to_int64(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Int64((int64_t) value);
+}
+static VALUE
+r_Float64_to_float32(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Float32((float) value);
+}
+static VALUE
+r_Float64_to_float64(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Float64((double) value);
+}
+static VALUE
+r_Float64_to_i(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __float64_to_i(value);
+}
+static VALUE
+r_Float64_to_f(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __float64_to_f(value);
+}
+static VALUE
+r_Float64_to_s(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __float64_to_s(value);
+}
+static VALUE
+r_Float64_eq(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return value == v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_ne(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return value != v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_pos(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Float64(+value);
+}
+static VALUE
+r_Float64_neg(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return __allocate_Float64(-value);
+}
+static VALUE
+r_Float64_mul(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return __allocate_Float64(value * v);
+}
+static VALUE
+r_Float64_div(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return __allocate_Float64(__float64_div(value, v));
+}
+static VALUE
+r_Float64_mod(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return __allocate_Float64(__float64_mod(value, v));
+}
+static VALUE
+r_Float64_add(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return __allocate_Float64(value + v);
+}
+static VALUE
+r_Float64_sub(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return __allocate_Float64(value - v);
+}
+static VALUE
+r_Float64_cmp(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	if (value < v)
+		return r_Int32_M1;
+	if (value > v)
+		return r_Int32_1;
+	return r_Int32_0;
+}
+static VALUE
+r_Float64_lt(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return value < v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_le(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return value <= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_ge(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return value >= v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_gt(VALUE self, VALUE o)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	double v = __object_f64(o);
+	return value > v ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_is_zero(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return value == 0 ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_is_nan(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return isnan(value) ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_is_infinite(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return isinf(value) ? Qtrue : Qfalse;
+}
+static VALUE
+r_Float64_is_finite(VALUE self)
+{
+	Float64 *p;
+	Data_Get_Struct(self, Float64, p);
+	double value = p->value;
+	return !isnan(value) && !isinf(value) ? Qtrue : Qfalse;
+}
+static VALUE
+r_ObjectArray_length(VALUE self)
+{
+	ObjectArray *p;
+	Data_Get_Struct(self, ObjectArray, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_ObjectArray_get(VALUE self, VALUE i)
+{
+	ObjectArray *p;
+	Data_Get_Struct(self, ObjectArray, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return p->data[__i];
+}
+static VALUE
+r_ObjectArray_set(VALUE self, VALUE i, VALUE e)
+{
+	ObjectArray *p;
+	Data_Get_Struct(self, ObjectArray, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = e;
+	return Qnil;
+}
+static void
+__copy_ObjectArray(ObjectArray *p0, int32_t i0, ObjectArray *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_ObjectArray_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	ObjectArray *p0;
+	Data_Get_Struct(self, ObjectArray, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_ObjectArray)
+		rb_raise(rb_eTypeError, "expected array");
+	ObjectArray *p1;
+	Data_Get_Struct(m1, ObjectArray, p1);
+	__copy_ObjectArray(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+r_BooleanArray_length(VALUE self)
+{
+	BooleanArray *p;
+	Data_Get_Struct(self, BooleanArray, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_BooleanArray_get(VALUE self, VALUE i)
+{
+	BooleanArray *p;
+	Data_Get_Struct(self, BooleanArray, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return p->data[__i] != 0 ? Qtrue : Qfalse;
+}
+static VALUE
+r_BooleanArray_set(VALUE self, VALUE i, VALUE e)
+{
+	BooleanArray *p;
+	Data_Get_Struct(self, BooleanArray, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = __object_to_boolean(e);
+	return Qnil;
+}
+static void
+__copy_BooleanArray(BooleanArray *p0, int32_t i0, BooleanArray *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_BooleanArray_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	BooleanArray *p0;
+	Data_Get_Struct(self, BooleanArray, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_BooleanArray)
+		rb_raise(rb_eTypeError, "expected array");
+	BooleanArray *p1;
+	Data_Get_Struct(m1, BooleanArray, p1);
+	__copy_BooleanArray(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+r_ByteArray_length(VALUE self)
+{
+	ByteArray *p;
+	Data_Get_Struct(self, ByteArray, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_ByteArray_get(VALUE self, VALUE i)
+{
+	ByteArray *p;
+	Data_Get_Struct(self, ByteArray, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return LONG2NUM((long) p->data[__i]);
+}
+static VALUE
+r_ByteArray_set(VALUE self, VALUE i, VALUE e)
+{
+	ByteArray *p;
+	Data_Get_Struct(self, ByteArray, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = (int8_t) __object_i32(e);
+	return Qnil;
+}
+static void
+__copy_ByteArray(ByteArray *p0, int32_t i0, ByteArray *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_ByteArray_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	ByteArray *p0;
+	Data_Get_Struct(self, ByteArray, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_ByteArray)
+		rb_raise(rb_eTypeError, "expected array");
+	ByteArray *p1;
+	Data_Get_Struct(m1, ByteArray, p1);
+	__copy_ByteArray(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+r_CharArray_length(VALUE self)
+{
+	CharArray *p;
+	Data_Get_Struct(self, CharArray, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_CharArray_get(VALUE self, VALUE i)
+{
+	CharArray *p;
+	Data_Get_Struct(self, CharArray, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return LONG2NUM((long) p->data[__i]);
+}
+static VALUE
+r_CharArray_set(VALUE self, VALUE i, VALUE e)
+{
+	CharArray *p;
+	Data_Get_Struct(self, CharArray, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = (uint16_t) __object_i32(e);
+	return Qnil;
+}
+static void
+__copy_CharArray(CharArray *p0, int32_t i0, CharArray *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_CharArray_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	CharArray *p0;
+	Data_Get_Struct(self, CharArray, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_CharArray)
+		rb_raise(rb_eTypeError, "expected array");
+	CharArray *p1;
+	Data_Get_Struct(m1, CharArray, p1);
+	__copy_CharArray(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+r_Int16Array_length(VALUE self)
+{
+	Int16Array *p;
+	Data_Get_Struct(self, Int16Array, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_Int16Array_get(VALUE self, VALUE i)
+{
+	Int16Array *p;
+	Data_Get_Struct(self, Int16Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return LONG2NUM((long) p->data[__i]);
+}
+static VALUE
+r_Int16Array_set(VALUE self, VALUE i, VALUE e)
+{
+	Int16Array *p;
+	Data_Get_Struct(self, Int16Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = (int16_t) __object_i32(e);
+	return Qnil;
+}
+static void
+__copy_Int16Array(Int16Array *p0, int32_t i0, Int16Array *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_Int16Array_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	Int16Array *p0;
+	Data_Get_Struct(self, Int16Array, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_Int16Array)
+		rb_raise(rb_eTypeError, "expected array");
+	Int16Array *p1;
+	Data_Get_Struct(m1, Int16Array, p1);
+	__copy_Int16Array(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+r_Int32Array_length(VALUE self)
+{
+	Int32Array *p;
+	Data_Get_Struct(self, Int32Array, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_Int32Array_get(VALUE self, VALUE i)
+{
+	Int32Array *p;
+	Data_Get_Struct(self, Int32Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return LONG2NUM((long) p->data[__i]);
+}
+static VALUE
+r_Int32Array_set(VALUE self, VALUE i, VALUE e)
+{
+	Int32Array *p;
+	Data_Get_Struct(self, Int32Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = (int32_t) __object_i32(e);
+	return Qnil;
+}
+static void
+__copy_Int32Array(Int32Array *p0, int32_t i0, Int32Array *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_Int32Array_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	Int32Array *p0;
+	Data_Get_Struct(self, Int32Array, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_Int32Array)
+		rb_raise(rb_eTypeError, "expected array");
+	Int32Array *p1;
+	Data_Get_Struct(m1, Int32Array, p1);
+	__copy_Int32Array(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+r_Int64Array_length(VALUE self)
+{
+	Int64Array *p;
+	Data_Get_Struct(self, Int64Array, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_Int64Array_get(VALUE self, VALUE i)
+{
+	Int64Array *p;
+	Data_Get_Struct(self, Int64Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return LONG2NUM((long) p->data[__i]);
+}
+static VALUE
+r_Int64Array_set(VALUE self, VALUE i, VALUE e)
+{
+	Int64Array *p;
+	Data_Get_Struct(self, Int64Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = (int64_t) __object_i64(e);
+	return Qnil;
+}
+static void
+__copy_Int64Array(Int64Array *p0, int32_t i0, Int64Array *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_Int64Array_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	Int64Array *p0;
+	Data_Get_Struct(self, Int64Array, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_Int64Array)
+		rb_raise(rb_eTypeError, "expected array");
+	Int64Array *p1;
+	Data_Get_Struct(m1, Int64Array, p1);
+	__copy_Int64Array(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+r_Float32Array_length(VALUE self)
+{
+	Float32Array *p;
+	Data_Get_Struct(self, Float32Array, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_Float32Array_get(VALUE self, VALUE i)
+{
+	Float32Array *p;
+	Data_Get_Struct(self, Float32Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return DBL2NUM((double) p->data[__i]);
+}
+static VALUE
+r_Float32Array_set(VALUE self, VALUE i, VALUE e)
+{
+	Float32Array *p;
+	Data_Get_Struct(self, Float32Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = (float) __object_f32(e);
+	return Qnil;
+}
+static void
+__copy_Float32Array(Float32Array *p0, int32_t i0, Float32Array *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_Float32Array_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	Float32Array *p0;
+	Data_Get_Struct(self, Float32Array, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_Float32Array)
+		rb_raise(rb_eTypeError, "expected array");
+	Float32Array *p1;
+	Data_Get_Struct(m1, Float32Array, p1);
+	__copy_Float32Array(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+r_Float64Array_length(VALUE self)
+{
+	Float64Array *p;
+	Data_Get_Struct(self, Float64Array, p);
+	return LONG2NUM(p->length);
+}
+static VALUE
+r_Float64Array_get(VALUE self, VALUE i)
+{
+	Float64Array *p;
+	Data_Get_Struct(self, Float64Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	return DBL2NUM((double) p->data[__i]);
+}
+static VALUE
+r_Float64Array_set(VALUE self, VALUE i, VALUE e)
+{
+	Float64Array *p;
+	Data_Get_Struct(self, Float64Array, p);
+	int32_t __i = __assert_bounds(i, p->length);
+	p->data[__i] = (double) __object_f64(e);
+	return Qnil;
+}
+static void
+__copy_Float64Array(Float64Array *p0, int32_t i0, Float64Array *p1, int32_t i1, int32_t n)
+{
+	int32_t j0 = i0 + n;
+	int32_t j1 = i1 + n;
+	if (j0 < 0 || j0 > p0->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	if (j1 < 0 || j1 > p1->length)
+		rb_raise(rb_eArgError, "index out of bounds");
+	while (n-- > 0)
+		p1->data[i1++] = p0->data[i0++];
+	return;
+}
+static VALUE
+r_Float64Array_copy(VALUE self, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	Float64Array *p0;
+	Data_Get_Struct(self, Float64Array, p0);
+	if (TYPE(m1) != T_DATA || RBASIC(m1)->klass != r_Float64Array)
+		rb_raise(rb_eTypeError, "expected array");
+	Float64Array *p1;
+	Data_Get_Struct(m1, Float64Array, p1);
+	__copy_Float64Array(p0, __assert_nat32(i0), p1, __assert_nat32(i1), __assert_nat32(n));
+	return Qnil;
+}
+static VALUE
+__outer(VALUE self)
+{
+	VALUE klass;
+	klass = rb_ivar_get(self, OUTER_ID);
+	if (NIL_P(klass)) {
+		klass = rb_class_boot(r_ObjectArray);
+		rb_singleton_class(klass);
+		rb_undef_alloc_func(klass);
+		rb_ivar_set(klass, INNER_ID, self);
+		rb_ivar_set(self, OUTER_ID, klass);
+	}
+	return klass;
+}
+static VALUE
+__allocate_ArrayFactory(VALUE klass, int c)
+{
+	ArrayFactory *p = xmalloc(sizeof(ArrayFactory) + sizeof(VALUE) * c);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	int b;
+	for (b = 1; b < c; b += 1)
+		klass = __outer(klass);
+	p->klass = klass;
+	p->length = c;
+	for (b = 0; b < c; b += 1)
+		p->data[b] = Qnil;
+	return Data_Wrap_Struct(r_ArrayFactory, NULL, NULL, p);
+}
+static VALUE
+__allocate_ArrayFactoryFactory(VALUE klass)
+{
+	ArrayFactoryFactory *p = ALLOC(ArrayFactoryFactory);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->klass = klass;
+	return Data_Wrap_Struct(r_ArrayFactoryFactory, NULL, NULL, p);
+}
+static VALUE
+r_ArrayFactory_new(VALUE self)
+{
+	ArrayFactory *p;
+	Data_Get_Struct(self, ArrayFactory, p);
+	return __new_Array(p->klass, p->data, 0, p->length);
+}
+static VALUE
+__new_ArrayFactory(VALUE klass, VALUE *data, int c)
+{
+	VALUE r = __allocate_ArrayFactory(klass, c);
+	ArrayFactory *p;
+	Data_Get_Struct(r, ArrayFactory, p);
+	int b;
+	for (b = 0; b < c; b += 1) {
+		VALUE e = data[b];
+		int32_t n = __assert_nat32(e);
+		p->data[b] = __allocate_Int32(n);
+	}
+	return r;
+}
+static VALUE
+__splat(VALUE self, VALUE args)
+{
+	int c = RARRAY_LEN(args);
+	if (c == 0)
+		return self;
+	VALUE *data = RARRAY_PTR(args);
+	return __new_ArrayFactory(self, data, c);
+}
+static VALUE
+r_ArrayFactoryFactory_splat(VALUE self, VALUE args)
+{
+	ArrayFactoryFactory *p;
+	Data_Get_Struct(self, ArrayFactoryFactory, p);
+	VALUE klass = p->klass;
+	return __splat(klass, args);
+}
+static VALUE
+r_Array_splat(VALUE self, VALUE args)
+{
+	VALUE klass = __outer(self);
+	return __splat(klass, args);
+}
+static VALUE
+r_Java_ARRAYCOPY(VALUE self, VALUE m0, VALUE i0, VALUE m1, VALUE i1, VALUE n)
+{
+	rb_funcall(m0, COPY_ID, 4, i0, m1, i1, n);
+	return Qnil;
+}
+static VALUE
+r_String_from_java_bytes(VALUE self, VALUE a)
+{
+	if (TYPE(a) != T_DATA || RBASIC(a)->klass != r_ByteArray)
+		rb_raise(rb_eTypeError, "expected byte[]");
+	ByteArray *p;
+	Data_Get_Struct(a, ByteArray, p);
+	return rb_str_new((char*) p->data, p->length);
+}
+static VALUE
+r_String_to_java_bytes(VALUE self)
+{
+	int32_t n = RSTRING_LEN(self);
+	char *data = RSTRING_PTR(self);
+	ByteArray *p = xmalloc(sizeof(ByteArray) + sizeof(int8_t) * n);
+	if (p == NULL)
+		rb_raise(rb_eNoMemError, "NoMemoryError");
+	p->length = n;
+	int32_t i;
+	for (i = 0; i < n; i += 1)
+		p->data[i] = data[i];
+	return Data_Wrap_Struct(r_ByteArray, NULL, NULL, p);
+}
+void
+Init_primitive()
+{
+	r_Integer_x8000000000000000 = ULONG2NUM(0x8000000000000000UL);
+	rb_global_variable(&r_Integer_x8000000000000000);
+	r_Integer_xFFFFFFFFFFFFFFFF = ULONG2NUM(0xFFFFFFFFFFFFFFFFUL);
+	rb_global_variable(&r_Integer_xFFFFFFFFFFFFFFFF);
+	r_Integer_xM8000000000000000 = LONG2NUM(-0x8000000000000000L);
+	rb_global_variable(&r_Integer_xM8000000000000000);
+	r_Byte = rb_define_class("Byte", rb_cObject);
+	rb_undef_alloc_func(r_Byte);
+	rb_define_module_function(r_Byte, "[]", r_Byte_new, 1);
+	rb_define_method(r_Byte, "eql?", r_Byte_is_eql, 1);
+	rb_define_method(r_Byte, "hash", r_Byte_hash, 0);
+	rb_define_method(r_Byte, "as_i", r_Byte_to_i, 0);
+	rb_define_method(r_Byte, "as_f", r_Byte_to_f, 0);
+	rb_define_method(r_Byte, "to_byte", r_Byte_to_byte, 0);
+	rb_define_method(r_Byte, "to_char", r_Byte_to_char, 0);
+	rb_define_method(r_Byte, "to_int16", r_Byte_to_int16, 0);
+	rb_define_method(r_Byte, "to_int32", r_Byte_to_int32, 0);
+	rb_define_method(r_Byte, "to_int64", r_Byte_to_int64, 0);
+	rb_define_method(r_Byte, "to_float32", r_Byte_to_float32, 0);
+	rb_define_method(r_Byte, "to_float64", r_Byte_to_float64, 0);
+	rb_define_method(r_Byte, "to_i", r_Byte_to_i, 0);
+	rb_define_method(r_Byte, "to_int", r_Byte_to_i, 0);
+	rb_define_method(r_Byte, "to_f", r_Byte_to_f, 0);
+	rb_define_method(r_Byte, "to_s", r_Byte_to_s, 0);
+	rb_define_method(r_Byte, "inspect", r_Byte_to_s, 0);
+	rb_define_method(r_Byte, "==", r_Byte_eq, 1);
+	rb_define_method(r_Byte, "!=", r_Byte_ne, 1);
+	rb_define_method(r_Byte, "+@", r_Byte_pos, 0);
+	rb_define_method(r_Byte, "-@", r_Byte_neg, 0);
+	rb_define_method(r_Byte, "*", r_Byte_mul, 1);
+	rb_define_method(r_Byte, "/", r_Byte_div, 1);
+	rb_define_method(r_Byte, "%", r_Byte_mod, 1);
+	rb_define_method(r_Byte, "+", r_Byte_add, 1);
+	rb_define_method(r_Byte, "-", r_Byte_sub, 1);
+	rb_define_method(r_Byte, "<=>", r_Byte_cmp, 1);
+	rb_define_method(r_Byte, "<", r_Byte_lt, 1);
+	rb_define_method(r_Byte, "<=", r_Byte_le, 1);
+	rb_define_method(r_Byte, ">=", r_Byte_ge, 1);
+	rb_define_method(r_Byte, ">", r_Byte_gt, 1);
+	rb_define_method(r_Byte, "~", r_Byte_inv, 0);
+	rb_define_method(r_Byte, "<<", r_Byte_shl, 1);
+	rb_define_method(r_Byte, ">>", r_Byte_shr, 1);
+	rb_define_method(r_Byte, "ushr", r_Byte_ushr, 1);
+	rb_define_method(r_Byte, "&", r_Byte_and, 1);
+	rb_define_method(r_Byte, "^", r_Byte_xor, 1);
+	rb_define_method(r_Byte, "|", r_Byte_or, 1);
+	rb_define_method(r_Byte, "zero?", r_Byte_is_zero, 0);
+	r_Char = rb_define_class("Char", rb_cObject);
+	rb_undef_alloc_func(r_Char);
+	rb_define_module_function(r_Char, "[]", r_Char_new, 1);
+	rb_define_method(r_Char, "eql?", r_Char_is_eql, 1);
+	rb_define_method(r_Char, "hash", r_Char_hash, 0);
+	rb_define_method(r_Char, "as_i", r_Char_to_i, 0);
+	rb_define_method(r_Char, "as_f", r_Char_to_f, 0);
+	rb_define_method(r_Char, "to_byte", r_Char_to_byte, 0);
+	rb_define_method(r_Char, "to_char", r_Char_to_char, 0);
+	rb_define_method(r_Char, "to_int16", r_Char_to_int16, 0);
+	rb_define_method(r_Char, "to_int32", r_Char_to_int32, 0);
+	rb_define_method(r_Char, "to_int64", r_Char_to_int64, 0);
+	rb_define_method(r_Char, "to_float32", r_Char_to_float32, 0);
+	rb_define_method(r_Char, "to_float64", r_Char_to_float64, 0);
+	rb_define_method(r_Char, "to_i", r_Char_to_i, 0);
+	rb_define_method(r_Char, "to_int", r_Char_to_i, 0);
+	rb_define_method(r_Char, "to_f", r_Char_to_f, 0);
+	rb_define_method(r_Char, "to_s", r_Char_to_s, 0);
+	rb_define_method(r_Char, "inspect", r_Char_to_s, 0);
+	rb_define_method(r_Char, "==", r_Char_eq, 1);
+	rb_define_method(r_Char, "!=", r_Char_ne, 1);
+	rb_define_method(r_Char, "+@", r_Char_pos, 0);
+	rb_define_method(r_Char, "-@", r_Char_neg, 0);
+	rb_define_method(r_Char, "*", r_Char_mul, 1);
+	rb_define_method(r_Char, "/", r_Char_div, 1);
+	rb_define_method(r_Char, "%", r_Char_mod, 1);
+	rb_define_method(r_Char, "+", r_Char_add, 1);
+	rb_define_method(r_Char, "-", r_Char_sub, 1);
+	rb_define_method(r_Char, "<=>", r_Char_cmp, 1);
+	rb_define_method(r_Char, "<", r_Char_lt, 1);
+	rb_define_method(r_Char, "<=", r_Char_le, 1);
+	rb_define_method(r_Char, ">=", r_Char_ge, 1);
+	rb_define_method(r_Char, ">", r_Char_gt, 1);
+	rb_define_method(r_Char, "~", r_Char_inv, 0);
+	rb_define_method(r_Char, "<<", r_Char_shl, 1);
+	rb_define_method(r_Char, ">>", r_Char_shr, 1);
+	rb_define_method(r_Char, "ushr", r_Char_ushr, 1);
+	rb_define_method(r_Char, "&", r_Char_and, 1);
+	rb_define_method(r_Char, "^", r_Char_xor, 1);
+	rb_define_method(r_Char, "|", r_Char_or, 1);
+	rb_define_method(r_Char, "zero?", r_Char_is_zero, 0);
+	r_Int16 = rb_define_class("Int16", rb_cObject);
+	rb_undef_alloc_func(r_Int16);
+	rb_define_module_function(r_Int16, "[]", r_Int16_new, 1);
+	rb_define_method(r_Int16, "eql?", r_Int16_is_eql, 1);
+	rb_define_method(r_Int16, "hash", r_Int16_hash, 0);
+	rb_define_method(r_Int16, "as_i", r_Int16_to_i, 0);
+	rb_define_method(r_Int16, "as_f", r_Int16_to_f, 0);
+	rb_define_method(r_Int16, "to_byte", r_Int16_to_byte, 0);
+	rb_define_method(r_Int16, "to_char", r_Int16_to_char, 0);
+	rb_define_method(r_Int16, "to_int16", r_Int16_to_int16, 0);
+	rb_define_method(r_Int16, "to_int32", r_Int16_to_int32, 0);
+	rb_define_method(r_Int16, "to_int64", r_Int16_to_int64, 0);
+	rb_define_method(r_Int16, "to_float32", r_Int16_to_float32, 0);
+	rb_define_method(r_Int16, "to_float64", r_Int16_to_float64, 0);
+	rb_define_method(r_Int16, "to_i", r_Int16_to_i, 0);
+	rb_define_method(r_Int16, "to_int", r_Int16_to_i, 0);
+	rb_define_method(r_Int16, "to_f", r_Int16_to_f, 0);
+	rb_define_method(r_Int16, "to_s", r_Int16_to_s, 0);
+	rb_define_method(r_Int16, "inspect", r_Int16_to_s, 0);
+	rb_define_method(r_Int16, "==", r_Int16_eq, 1);
+	rb_define_method(r_Int16, "!=", r_Int16_ne, 1);
+	rb_define_method(r_Int16, "+@", r_Int16_pos, 0);
+	rb_define_method(r_Int16, "-@", r_Int16_neg, 0);
+	rb_define_method(r_Int16, "*", r_Int16_mul, 1);
+	rb_define_method(r_Int16, "/", r_Int16_div, 1);
+	rb_define_method(r_Int16, "%", r_Int16_mod, 1);
+	rb_define_method(r_Int16, "+", r_Int16_add, 1);
+	rb_define_method(r_Int16, "-", r_Int16_sub, 1);
+	rb_define_method(r_Int16, "<=>", r_Int16_cmp, 1);
+	rb_define_method(r_Int16, "<", r_Int16_lt, 1);
+	rb_define_method(r_Int16, "<=", r_Int16_le, 1);
+	rb_define_method(r_Int16, ">=", r_Int16_ge, 1);
+	rb_define_method(r_Int16, ">", r_Int16_gt, 1);
+	rb_define_method(r_Int16, "~", r_Int16_inv, 0);
+	rb_define_method(r_Int16, "<<", r_Int16_shl, 1);
+	rb_define_method(r_Int16, ">>", r_Int16_shr, 1);
+	rb_define_method(r_Int16, "ushr", r_Int16_ushr, 1);
+	rb_define_method(r_Int16, "&", r_Int16_and, 1);
+	rb_define_method(r_Int16, "^", r_Int16_xor, 1);
+	rb_define_method(r_Int16, "|", r_Int16_or, 1);
+	rb_define_method(r_Int16, "zero?", r_Int16_is_zero, 0);
+	r_Int32 = rb_define_class("Int32", rb_cObject);
+	rb_undef_alloc_func(r_Int32);
+	rb_define_module_function(r_Int32, "[]", r_Int32_new, 1);
+	rb_define_method(r_Int32, "eql?", r_Int32_is_eql, 1);
+	rb_define_method(r_Int32, "hash", r_Int32_hash, 0);
+	rb_define_method(r_Int32, "as_i", r_Int32_to_i, 0);
+	rb_define_method(r_Int32, "as_f", r_Int32_to_f, 0);
+	rb_define_method(r_Int32, "to_byte", r_Int32_to_byte, 0);
+	rb_define_method(r_Int32, "to_char", r_Int32_to_char, 0);
+	rb_define_method(r_Int32, "to_int16", r_Int32_to_int16, 0);
+	rb_define_method(r_Int32, "to_int32", r_Int32_to_int32, 0);
+	rb_define_method(r_Int32, "to_int64", r_Int32_to_int64, 0);
+	rb_define_method(r_Int32, "to_float32", r_Int32_to_float32, 0);
+	rb_define_method(r_Int32, "to_float64", r_Int32_to_float64, 0);
+	rb_define_method(r_Int32, "to_i", r_Int32_to_i, 0);
+	rb_define_method(r_Int32, "to_int", r_Int32_to_i, 0);
+	rb_define_method(r_Int32, "to_f", r_Int32_to_f, 0);
+	rb_define_method(r_Int32, "to_s", r_Int32_to_s, 0);
+	rb_define_method(r_Int32, "inspect", r_Int32_to_s, 0);
+	rb_define_method(r_Int32, "==", r_Int32_eq, 1);
+	rb_define_method(r_Int32, "!=", r_Int32_ne, 1);
+	rb_define_method(r_Int32, "+@", r_Int32_pos, 0);
+	rb_define_method(r_Int32, "-@", r_Int32_neg, 0);
+	rb_define_method(r_Int32, "*", r_Int32_mul, 1);
+	rb_define_method(r_Int32, "/", r_Int32_div, 1);
+	rb_define_method(r_Int32, "%", r_Int32_mod, 1);
+	rb_define_method(r_Int32, "+", r_Int32_add, 1);
+	rb_define_method(r_Int32, "-", r_Int32_sub, 1);
+	rb_define_method(r_Int32, "<=>", r_Int32_cmp, 1);
+	rb_define_method(r_Int32, "<", r_Int32_lt, 1);
+	rb_define_method(r_Int32, "<=", r_Int32_le, 1);
+	rb_define_method(r_Int32, ">=", r_Int32_ge, 1);
+	rb_define_method(r_Int32, ">", r_Int32_gt, 1);
+	rb_define_method(r_Int32, "~", r_Int32_inv, 0);
+	rb_define_method(r_Int32, "<<", r_Int32_shl, 1);
+	rb_define_method(r_Int32, ">>", r_Int32_shr, 1);
+	rb_define_method(r_Int32, "ushr", r_Int32_ushr, 1);
+	rb_define_method(r_Int32, "&", r_Int32_and, 1);
+	rb_define_method(r_Int32, "^", r_Int32_xor, 1);
+	rb_define_method(r_Int32, "|", r_Int32_or, 1);
+	rb_define_method(r_Int32, "zero?", r_Int32_is_zero, 0);
+	rb_define_method(r_Int32, "to_int32!", r_Int32_bang_to_int32, 0);
+	rb_define_method(r_Int32, "to_int64!", r_Int32_bang_to_int64, 0);
+	rb_define_method(r_Int32, "to_fixnum", r_Int32_to_fixnum, 0);
+	rb_define_method(r_Int32, "new_fixnum", r_Int32_to_fixnum, 0);
+	rb_define_method(r_Int32, "to_hex", r_Int32_to_hex, 0);
+	rb_define_method(r_Int32, "chr", r_Int32_chr, 0);
+	rb_define_method(r_Int32, "rol", r_Int32_rol, 1);
+	rb_define_method(r_Int32, "ror", r_Int32_ror, 1);
+	rb_define_method(r_Int32, "count", r_Int32_count, 0);
+	rb_define_method(r_Int32, "signum", r_Int32_signum, 0);
+	rb_define_method(r_Int32, "times", r_Int32_times, 0);
+	rb_define_method(r_Int32, "upto", r_Int32_upto, 1);
+	rb_define_method(r_Int32, "downto", r_Int32_downto, 1);
+	r_Int64 = rb_define_class("Int64", rb_cObject);
+	rb_undef_alloc_func(r_Int64);
+	rb_define_module_function(r_Int64, "[]", r_Int64_new, 1);
+	rb_define_method(r_Int64, "eql?", r_Int64_is_eql, 1);
+	rb_define_method(r_Int64, "hash", r_Int64_hash, 0);
+	rb_define_method(r_Int64, "as_i", r_Int64_to_i, 0);
+	rb_define_method(r_Int64, "as_f", r_Int64_to_f, 0);
+	rb_define_method(r_Int64, "to_byte", r_Int64_to_byte, 0);
+	rb_define_method(r_Int64, "to_char", r_Int64_to_char, 0);
+	rb_define_method(r_Int64, "to_int16", r_Int64_to_int16, 0);
+	rb_define_method(r_Int64, "to_int32", r_Int64_to_int32, 0);
+	rb_define_method(r_Int64, "to_int64", r_Int64_to_int64, 0);
+	rb_define_method(r_Int64, "to_float32", r_Int64_to_float32, 0);
+	rb_define_method(r_Int64, "to_float64", r_Int64_to_float64, 0);
+	rb_define_method(r_Int64, "to_i", r_Int64_to_i, 0);
+	rb_define_method(r_Int64, "to_int", r_Int64_to_i, 0);
+	rb_define_method(r_Int64, "to_f", r_Int64_to_f, 0);
+	rb_define_method(r_Int64, "to_s", r_Int64_to_s, 0);
+	rb_define_method(r_Int64, "inspect", r_Int64_to_s, 0);
+	rb_define_method(r_Int64, "==", r_Int64_eq, 1);
+	rb_define_method(r_Int64, "!=", r_Int64_ne, 1);
+	rb_define_method(r_Int64, "+@", r_Int64_pos, 0);
+	rb_define_method(r_Int64, "-@", r_Int64_neg, 0);
+	rb_define_method(r_Int64, "*", r_Int64_mul, 1);
+	rb_define_method(r_Int64, "/", r_Int64_div, 1);
+	rb_define_method(r_Int64, "%", r_Int64_mod, 1);
+	rb_define_method(r_Int64, "+", r_Int64_add, 1);
+	rb_define_method(r_Int64, "-", r_Int64_sub, 1);
+	rb_define_method(r_Int64, "<=>", r_Int64_cmp, 1);
+	rb_define_method(r_Int64, "<", r_Int64_lt, 1);
+	rb_define_method(r_Int64, "<=", r_Int64_le, 1);
+	rb_define_method(r_Int64, ">=", r_Int64_ge, 1);
+	rb_define_method(r_Int64, ">", r_Int64_gt, 1);
+	rb_define_method(r_Int64, "~", r_Int64_inv, 0);
+	rb_define_method(r_Int64, "<<", r_Int64_shl, 1);
+	rb_define_method(r_Int64, ">>", r_Int64_shr, 1);
+	rb_define_method(r_Int64, "ushr", r_Int64_ushr, 1);
+	rb_define_method(r_Int64, "&", r_Int64_and, 1);
+	rb_define_method(r_Int64, "^", r_Int64_xor, 1);
+	rb_define_method(r_Int64, "|", r_Int64_or, 1);
+	rb_define_method(r_Int64, "zero?", r_Int64_is_zero, 0);
+	rb_define_method(r_Int64, "to_int32!", r_Int64_bang_to_int32, 0);
+	rb_define_method(r_Int64, "to_int64!", r_Int64_bang_to_int64, 0);
+	rb_define_method(r_Int64, "to_fixnum", r_Int64_to_fixnum, 0);
+	rb_define_method(r_Int64, "new_fixnum", r_Int64_to_fixnum, 0);
+	rb_define_method(r_Int64, "to_hex", r_Int64_to_hex, 0);
+	rb_define_method(r_Int64, "rol", r_Int64_rol, 1);
+	rb_define_method(r_Int64, "ror", r_Int64_ror, 1);
+	rb_define_method(r_Int64, "count", r_Int64_count, 0);
+	rb_define_method(r_Int64, "signum", r_Int64_signum, 0);
+	rb_define_method(r_Int64, "times", r_Int64_times, 0);
+	r_Float32 = rb_define_class("Float32", rb_cObject);
+	rb_undef_alloc_func(r_Float32);
+	rb_define_module_function(r_Float32, "[]", r_Float32_new, 1);
+	rb_define_method(r_Float32, "eql?", r_Float32_is_eql, 1);
+	rb_define_method(r_Float32, "hash", r_Float32_hash, 0);
+	rb_define_method(r_Float32, "as_i", r_Float32_to_i, 0);
+	rb_define_method(r_Float32, "as_f", r_Float32_to_f, 0);
+	rb_define_method(r_Float32, "to_byte", r_Float32_to_byte, 0);
+	rb_define_method(r_Float32, "to_char", r_Float32_to_char, 0);
+	rb_define_method(r_Float32, "to_int16", r_Float32_to_int16, 0);
+	rb_define_method(r_Float32, "to_int32", r_Float32_to_int32, 0);
+	rb_define_method(r_Float32, "to_int64", r_Float32_to_int64, 0);
+	rb_define_method(r_Float32, "to_float32", r_Float32_to_float32, 0);
+	rb_define_method(r_Float32, "to_float64", r_Float32_to_float64, 0);
+	rb_define_method(r_Float32, "to_i", r_Float32_to_i, 0);
+	rb_define_method(r_Float32, "to_int", r_Float32_to_i, 0);
+	rb_define_method(r_Float32, "to_f", r_Float32_to_f, 0);
+	rb_define_method(r_Float32, "to_s", r_Float32_to_s, 0);
+	rb_define_method(r_Float32, "inspect", r_Float32_to_s, 0);
+	rb_define_method(r_Float32, "==", r_Float32_eq, 1);
+	rb_define_method(r_Float32, "!=", r_Float32_ne, 1);
+	rb_define_method(r_Float32, "+@", r_Float32_pos, 0);
+	rb_define_method(r_Float32, "-@", r_Float32_neg, 0);
+	rb_define_method(r_Float32, "*", r_Float32_mul, 1);
+	rb_define_method(r_Float32, "/", r_Float32_div, 1);
+	rb_define_method(r_Float32, "%", r_Float32_mod, 1);
+	rb_define_method(r_Float32, "+", r_Float32_add, 1);
+	rb_define_method(r_Float32, "-", r_Float32_sub, 1);
+	rb_define_method(r_Float32, "<=>", r_Float32_cmp, 1);
+	rb_define_method(r_Float32, "<", r_Float32_lt, 1);
+	rb_define_method(r_Float32, "<=", r_Float32_le, 1);
+	rb_define_method(r_Float32, ">=", r_Float32_ge, 1);
+	rb_define_method(r_Float32, ">", r_Float32_gt, 1);
+	rb_define_method(r_Float32, "zero?", r_Float32_is_zero, 0);
+	rb_define_method(r_Float32, "nan?", r_Float32_is_nan, 0);
+	rb_define_method(r_Float32, "infinite?", r_Float32_is_infinite, 0);
+	rb_define_method(r_Float32, "finite?", r_Float32_is_finite, 0);
+	rb_define_const(r_Float32, "NEGATIVE_INFINITY", __allocate_Float32(-INFINITY));
+	rb_define_const(r_Float32, "POSITIVE_INFINITY", __allocate_Float32(INFINITY));
+	r_Float64 = rb_define_class("Float64", rb_cObject);
+	rb_undef_alloc_func(r_Float64);
+	rb_define_module_function(r_Float64, "[]", r_Float64_new, 1);
+	rb_define_method(r_Float64, "eql?", r_Float64_is_eql, 1);
+	rb_define_method(r_Float64, "hash", r_Float64_hash, 0);
+	rb_define_method(r_Float64, "as_i", r_Float64_to_i, 0);
+	rb_define_method(r_Float64, "as_f", r_Float64_to_f, 0);
+	rb_define_method(r_Float64, "to_byte", r_Float64_to_byte, 0);
+	rb_define_method(r_Float64, "to_char", r_Float64_to_char, 0);
+	rb_define_method(r_Float64, "to_int16", r_Float64_to_int16, 0);
+	rb_define_method(r_Float64, "to_int32", r_Float64_to_int32, 0);
+	rb_define_method(r_Float64, "to_int64", r_Float64_to_int64, 0);
+	rb_define_method(r_Float64, "to_float32", r_Float64_to_float32, 0);
+	rb_define_method(r_Float64, "to_float64", r_Float64_to_float64, 0);
+	rb_define_method(r_Float64, "to_i", r_Float64_to_i, 0);
+	rb_define_method(r_Float64, "to_int", r_Float64_to_i, 0);
+	rb_define_method(r_Float64, "to_f", r_Float64_to_f, 0);
+	rb_define_method(r_Float64, "to_s", r_Float64_to_s, 0);
+	rb_define_method(r_Float64, "inspect", r_Float64_to_s, 0);
+	rb_define_method(r_Float64, "==", r_Float64_eq, 1);
+	rb_define_method(r_Float64, "!=", r_Float64_ne, 1);
+	rb_define_method(r_Float64, "+@", r_Float64_pos, 0);
+	rb_define_method(r_Float64, "-@", r_Float64_neg, 0);
+	rb_define_method(r_Float64, "*", r_Float64_mul, 1);
+	rb_define_method(r_Float64, "/", r_Float64_div, 1);
+	rb_define_method(r_Float64, "%", r_Float64_mod, 1);
+	rb_define_method(r_Float64, "+", r_Float64_add, 1);
+	rb_define_method(r_Float64, "-", r_Float64_sub, 1);
+	rb_define_method(r_Float64, "<=>", r_Float64_cmp, 1);
+	rb_define_method(r_Float64, "<", r_Float64_lt, 1);
+	rb_define_method(r_Float64, "<=", r_Float64_le, 1);
+	rb_define_method(r_Float64, ">=", r_Float64_ge, 1);
+	rb_define_method(r_Float64, ">", r_Float64_gt, 1);
+	rb_define_method(r_Float64, "zero?", r_Float64_is_zero, 0);
+	rb_define_method(r_Float64, "nan?", r_Float64_is_nan, 0);
+	rb_define_method(r_Float64, "infinite?", r_Float64_is_infinite, 0);
+	rb_define_method(r_Float64, "finite?", r_Float64_is_finite, 0);
+	rb_define_const(r_Float64, "NEGATIVE_INFINITY", __allocate_Float64(-INFINITY));
+	rb_define_const(r_Float64, "POSITIVE_INFINITY", __allocate_Float64(INFINITY));
+	r_Int32_0 = __allocate_Int32(0);
+	rb_global_variable(&r_Int32_0);
+	r_Int32_1 = __allocate_Int32(1);
+	rb_global_variable(&r_Int32_1);
+	r_Int32_M1 = __allocate_Int32(-1);
+	rb_global_variable(&r_Int32_M1);
+	NEW_ID = rb_intern("new");
+	INNER_ID = rb_intern("inner");
+	OUTER_ID = rb_intern("outer");
+	COPY_ID = rb_intern("copy");
+	r_ObjectArray = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_ObjectArray);
+	rb_global_variable(&r_ObjectArray);
+	rb_define_module_function(r_ObjectArray, "new", r_ObjectArray_new, 1);
+	rb_define_module_function(r_ObjectArray, "[]", r_Array_splat, -2);
+	rb_define_method(r_ObjectArray, "length", r_ObjectArray_length, 0);
+	rb_define_method(r_ObjectArray, "[]", r_ObjectArray_get, 1);
+	rb_define_method(r_ObjectArray, "[]=", r_ObjectArray_set, 2);
+	rb_define_method(r_ObjectArray, "copy", r_ObjectArray_copy, 4);
+	r_BooleanArray = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_BooleanArray);
+	rb_global_variable(&r_BooleanArray);
+	rb_define_module_function(r_BooleanArray, "new", r_BooleanArray_new, 1);
+	rb_define_module_function(r_BooleanArray, "[]", r_Array_splat, -2);
+	rb_define_method(r_BooleanArray, "length", r_BooleanArray_length, 0);
+	rb_define_method(r_BooleanArray, "[]", r_BooleanArray_get, 1);
+	rb_define_method(r_BooleanArray, "[]=", r_BooleanArray_set, 2);
+	rb_define_method(r_BooleanArray, "copy", r_BooleanArray_copy, 4);
+	r_ByteArray = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_ByteArray);
+	rb_global_variable(&r_ByteArray);
+	rb_define_module_function(r_ByteArray, "new", r_ByteArray_new, 1);
+	rb_define_module_function(r_ByteArray, "[]", r_Array_splat, -2);
+	rb_define_method(r_ByteArray, "length", r_ByteArray_length, 0);
+	rb_define_method(r_ByteArray, "[]", r_ByteArray_get, 1);
+	rb_define_method(r_ByteArray, "[]=", r_ByteArray_set, 2);
+	rb_define_method(r_ByteArray, "copy", r_ByteArray_copy, 4);
+	r_CharArray = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_CharArray);
+	rb_global_variable(&r_CharArray);
+	rb_define_module_function(r_CharArray, "new", r_CharArray_new, 1);
+	rb_define_module_function(r_CharArray, "[]", r_Array_splat, -2);
+	rb_define_method(r_CharArray, "length", r_CharArray_length, 0);
+	rb_define_method(r_CharArray, "[]", r_CharArray_get, 1);
+	rb_define_method(r_CharArray, "[]=", r_CharArray_set, 2);
+	rb_define_method(r_CharArray, "copy", r_CharArray_copy, 4);
+	r_Int16Array = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_Int16Array);
+	rb_global_variable(&r_Int16Array);
+	rb_define_module_function(r_Int16Array, "new", r_Int16Array_new, 1);
+	rb_define_module_function(r_Int16Array, "[]", r_Array_splat, -2);
+	rb_define_method(r_Int16Array, "length", r_Int16Array_length, 0);
+	rb_define_method(r_Int16Array, "[]", r_Int16Array_get, 1);
+	rb_define_method(r_Int16Array, "[]=", r_Int16Array_set, 2);
+	rb_define_method(r_Int16Array, "copy", r_Int16Array_copy, 4);
+	r_Int32Array = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_Int32Array);
+	rb_global_variable(&r_Int32Array);
+	rb_define_module_function(r_Int32Array, "new", r_Int32Array_new, 1);
+	rb_define_module_function(r_Int32Array, "[]", r_Array_splat, -2);
+	rb_define_method(r_Int32Array, "length", r_Int32Array_length, 0);
+	rb_define_method(r_Int32Array, "[]", r_Int32Array_get, 1);
+	rb_define_method(r_Int32Array, "[]=", r_Int32Array_set, 2);
+	rb_define_method(r_Int32Array, "copy", r_Int32Array_copy, 4);
+	r_Int64Array = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_Int64Array);
+	rb_global_variable(&r_Int64Array);
+	rb_define_module_function(r_Int64Array, "new", r_Int64Array_new, 1);
+	rb_define_module_function(r_Int64Array, "[]", r_Array_splat, -2);
+	rb_define_method(r_Int64Array, "length", r_Int64Array_length, 0);
+	rb_define_method(r_Int64Array, "[]", r_Int64Array_get, 1);
+	rb_define_method(r_Int64Array, "[]=", r_Int64Array_set, 2);
+	rb_define_method(r_Int64Array, "copy", r_Int64Array_copy, 4);
+	r_Float32Array = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_Float32Array);
+	rb_global_variable(&r_Float32Array);
+	rb_define_module_function(r_Float32Array, "new", r_Float32Array_new, 1);
+	rb_define_module_function(r_Float32Array, "[]", r_Array_splat, -2);
+	rb_define_method(r_Float32Array, "length", r_Float32Array_length, 0);
+	rb_define_method(r_Float32Array, "[]", r_Float32Array_get, 1);
+	rb_define_method(r_Float32Array, "[]=", r_Float32Array_set, 2);
+	rb_define_method(r_Float32Array, "copy", r_Float32Array_copy, 4);
+	r_Float64Array = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_Float64Array);
+	rb_global_variable(&r_Float64Array);
+	rb_define_module_function(r_Float64Array, "new", r_Float64Array_new, 1);
+	rb_define_module_function(r_Float64Array, "[]", r_Array_splat, -2);
+	rb_define_method(r_Float64Array, "length", r_Float64Array_length, 0);
+	rb_define_method(r_Float64Array, "[]", r_Float64Array_get, 1);
+	rb_define_method(r_Float64Array, "[]=", r_Float64Array_set, 2);
+	rb_define_method(r_Float64Array, "copy", r_Float64Array_copy, 4);
+	r_ArrayFactory = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_ArrayFactory);
+	rb_global_variable(&r_ArrayFactory);
+	rb_define_method(r_ArrayFactory, "new", r_ArrayFactory_new, 0);
+	r_ArrayFactoryFactory = rb_class_boot(rb_cObject);
+	rb_undef_alloc_func(r_ArrayFactoryFactory);
+	rb_global_variable(&r_ArrayFactoryFactory);
+	rb_define_method(r_ArrayFactoryFactory, "[]", r_ArrayFactoryFactory_splat, -2);
+	r_BOOLEAN_ARRAY_FACTORY_FACTORY = __allocate_ArrayFactoryFactory(r_BooleanArray);
+	rb_global_variable(&r_BOOLEAN_ARRAY_FACTORY_FACTORY);
+	r_BYTE_ARRAY_FACTORY_FACTORY = __allocate_ArrayFactoryFactory(r_ByteArray);
+	rb_global_variable(&r_BYTE_ARRAY_FACTORY_FACTORY);
+	r_CHAR_ARRAY_FACTORY_FACTORY = __allocate_ArrayFactoryFactory(r_CharArray);
+	rb_global_variable(&r_CHAR_ARRAY_FACTORY_FACTORY);
+	r_INT16_ARRAY_FACTORY_FACTORY = __allocate_ArrayFactoryFactory(r_Int16Array);
+	rb_global_variable(&r_INT16_ARRAY_FACTORY_FACTORY);
+	r_INT32_ARRAY_FACTORY_FACTORY = __allocate_ArrayFactoryFactory(r_Int32Array);
+	rb_global_variable(&r_INT32_ARRAY_FACTORY_FACTORY);
+	r_INT64_ARRAY_FACTORY_FACTORY = __allocate_ArrayFactoryFactory(r_Int64Array);
+	rb_global_variable(&r_INT64_ARRAY_FACTORY_FACTORY);
+	r_FLOAT32_ARRAY_FACTORY_FACTORY = __allocate_ArrayFactoryFactory(r_Float32Array);
+	rb_global_variable(&r_FLOAT32_ARRAY_FACTORY_FACTORY);
+	r_FLOAT64_ARRAY_FACTORY_FACTORY = __allocate_ArrayFactoryFactory(r_Float64Array);
+	rb_global_variable(&r_FLOAT64_ARRAY_FACTORY_FACTORY);
+	r_Java = rb_define_module("Java");
+	rb_define_module_function(r_Java, "ARRAYCOPY", r_Java_ARRAYCOPY, 5);
+	rb_define_module_function(r_Java, "boolean", r_Java_boolean, 0);
+	rb_define_module_function(r_Java, "byte", r_Java_byte, 0);
+	rb_define_module_function(r_Java, "char", r_Java_char, 0);
+	rb_define_module_function(r_Java, "int16", r_Java_int16, 0);
+	rb_define_module_function(r_Java, "int32", r_Java_int32, 0);
+	rb_define_module_function(r_Java, "int64", r_Java_int64, 0);
+	rb_define_module_function(r_Java, "float32", r_Java_float32, 0);
+	rb_define_module_function(r_Java, "float64", r_Java_float64, 0);
+	rb_define_module_function(rb_cString, "from_java_bytes", r_String_from_java_bytes, 1);
+	rb_define_method(rb_cString, "to_java_bytes", r_String_to_java_bytes, 0);
+	return;
+}