infraruby-java 0.0.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2a4e9327a7765473984c6cf1a3020ce09975f54
-  data.tar.gz: f49db3ee97ee2d71c94454ba799191d0fa4ac937
+  metadata.gz: 695340b8f639541a70db860991e6deb3109f2766
+  data.tar.gz: 1decaa512ad372408cf4b704101fbe61829c6371
 SHA512:
-  metadata.gz: 5b6a002d8a3b439d2687b7aacab90d77f058d2e10645530470dfea8ce76bfafd9b36a327c9f66b316454ad90f755d2b2adf8e02899efb631ea162a376ba1b581
-  data.tar.gz: 68fe4898a5d25c50759bc1c7720ddd1eb74d219d0b9089370777ecd7fbab2c1af4261eac5d6411de32d7482ee3b3a39b48f34d07bb3aef7e4d386c31e65f7920
+  metadata.gz: 2f47f678b456c392b293b4f6100becc97cb34e4c88655cfb8722eee16d6e3b1808d21cc2d93a32cfb7d157bd8203365350ee5c06689336aa1a4b9e350b75cac5
+  data.tar.gz: 0fd2c27090641306e1abc09a28e86556bb4afdd0b59fa9652ec9b56f0d66e2d74c082b4d28693b2bf214c8738cf675875ec6efcf0130a68b3f889a8f8425a2f4

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011-2015 InfraRuby Vision
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,25 @@
+InfraRuby Java integration for Ruby interpreters
+================================================
+
+This gem provides the InfraRuby Java integration for Ruby interpreters.
+
+
+Example
+-------
+
+	require "infraruby-java"
+
+	c1 = Int32[1]
+	c2 = Int32[2]
+	puts c1 + c2
+
+
+Support
+-------
+
+InfraRuby Vision
+rubygems@infraruby.com
+
+http://infraruby.com/
+https://github.com/InfraRuby
+https://twitter.com/InfraRuby

data/ext/primitive/PrimitiveService.java

@@ -0,0 +1,2023 @@
+package primitive;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyInteger;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyBignum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+import org.jruby.util.ByteList;
+import org.jcodings.specific.ASCIIEncoding;
+import org.jcodings.specific.USASCIIEncoding;
+public class PrimitiveService implements BasicLibraryService {
+	static RubyBignum Integer_x8000000000000000;
+	static RubyBignum Integer_xFFFFFFFFFFFFFFFF;
+	static RubyFixnum Integer_xM8000000000000000;
+	static Int32 Int32_0;
+	static Int32 Int32_1;
+	static Int32 Int32_M1;
+	static RubyClass ByteClass;
+	static RubyClass CharClass;
+	static RubyClass Int16Class;
+	static RubyClass Int32Class;
+	static RubyClass Int64Class;
+	static RubyClass Float32Class;
+	static RubyClass Float64Class;
+	public static int __int32_div(Ruby runtime, int x, int y) {
+		if (y == 0)
+			throw runtime.newZeroDivisionError();
+		return x / y;
+	}
+	public static int __int32_mod(Ruby runtime, int x, int y) {
+		if (y == 0)
+			throw runtime.newZeroDivisionError();
+		return x % y;
+	}
+	public static long __int64_div(Ruby runtime, long x, long y) {
+		if (y == 0)
+			throw runtime.newZeroDivisionError();
+		return x / y;
+	}
+	public static long __int64_mod(Ruby runtime, long x, long y) {
+		if (y == 0)
+			throw runtime.newZeroDivisionError();
+		return x % y;
+	}
+	public static float __float32_div(Ruby runtime, float x, float y) {
+		return x / y;
+	}
+	public static float __float32_mod(Ruby runtime, float x, float y) {
+		return x % y;
+	}
+	public static double __float64_div(Ruby runtime, double x, double y) {
+		return x / y;
+	}
+	public static double __float64_mod(Ruby runtime, double x, double y) {
+		return x % y;
+	}
+	static long __bignum_to_int64(Ruby runtime, IRubyObject o) {
+		ThreadContext context = runtime.getCurrentContext();
+		o = Integer_x8000000000000000.op_plus(context, o);
+		o = Integer_xFFFFFFFFFFFFFFFF.op_and(context, o);
+		o = Integer_xM8000000000000000.op_plus(context, o);
+		return ((RubyInteger) o).getLongValue();
+	}
+	public static int __object_i32(Ruby runtime, IRubyObject o) {
+		if (o instanceof Byte)
+			return (int) ((Byte) o).value;
+		if (o instanceof Char)
+			return (int) ((Char) o).value;
+		if (o instanceof Int16)
+			return (int) ((Int16) o).value;
+		if (o instanceof Int32)
+			return (int) ((Int32) o).value;
+		if (o instanceof RubyFixnum)
+			return (int) ((RubyFixnum) o).getLongValue();
+		if (o instanceof RubyBignum)
+			return (int) __bignum_to_int64(runtime, o);
+		throw runtime.newTypeError("expected int32");
+	}
+	public static long __object_i64(Ruby runtime, IRubyObject o) {
+		if (o instanceof Int64)
+			return (long) ((Int64) o).value;
+		if (o instanceof RubyFixnum)
+			return (long) ((RubyFixnum) o).getLongValue();
+		if (o instanceof RubyBignum)
+			return (long) __bignum_to_int64(runtime, o);
+		throw runtime.newTypeError("expected int64");
+	}
+	public static float __object_f32(Ruby runtime, IRubyObject o) {
+		if (o instanceof Float32)
+			return (float) ((Float32) o).value;
+		if (o instanceof RubyFixnum)
+			return (float) ((RubyFixnum) o).getLongValue();
+		if (o instanceof RubyBignum)
+			return (float) ((RubyBignum) o).getDoubleValue();
+		if (o instanceof RubyFloat)
+			return (float) ((RubyFloat) o).getDoubleValue();
+		throw runtime.newTypeError("expected float32");
+	}
+	public static double __object_f64(Ruby runtime, IRubyObject o) {
+		if (o instanceof Float64)
+			return (double) ((Float64) o).value;
+		if (o instanceof RubyFixnum)
+			return (double) ((RubyFixnum) o).getLongValue();
+		if (o instanceof RubyBignum)
+			return (double) ((RubyBignum) o).getDoubleValue();
+		if (o instanceof RubyFloat)
+			return (double) ((RubyFloat) o).getDoubleValue();
+		throw runtime.newTypeError("expected float64");
+	}
+	static final java.nio.charset.Charset CHARSET_US_ASCII = java.nio.charset.Charset.forName("US-ASCII");
+	public static int __int32_hash(int value) {
+		return value;
+	}
+	public static RubyInteger __int32_to_i(Ruby runtime, int value) {
+		return RubyFixnum.newFixnum(runtime, (long) value);
+	}
+	public static RubyFloat __int32_to_f(Ruby runtime, int value) {
+		return RubyFloat.newFloat(runtime, (double) value);
+	}
+	public static ByteList __int32_to_s(Ruby runtime, int value) {
+		return new ByteList(Integer.toString(value).getBytes(CHARSET_US_ASCII), USASCIIEncoding.INSTANCE);
+	}
+	public static ByteList __int32_to_hex(Ruby runtime, int value) {
+		int n = 010;
+		byte[] m = new byte[n];
+		while (true) {
+			n -= 1;
+			int c = (int) value & 0x0F;
+			m[n] = (byte) (c < 10 ? c + 0x30 : c + 0x41 - 10);
+			if (n == 0)
+				break;
+			value >>= 4;
+		}
+		return new ByteList(m, USASCIIEncoding.INSTANCE);
+	}
+	public static ByteList __int32_chr(Ruby runtime, int value) {
+		if (value < 0x00)
+			throw runtime.newRangeError("out of range");
+		if (value <= 0x7F)
+			return new ByteList(new byte[] { (byte) value }, USASCIIEncoding.INSTANCE);
+		if (value <= 0xFF)
+			return new ByteList(new byte[] { (byte) value }, ASCIIEncoding.INSTANCE);
+		throw runtime.newRangeError("out of range");
+	}
+	public static int __int64_hash(long value) {
+		return (int) value ^ (int) (value >> 32);
+	}
+	public static RubyInteger __int64_to_i(Ruby runtime, long value) {
+		return RubyFixnum.newFixnum(runtime, (long) value);
+	}
+	public static RubyFloat __int64_to_f(Ruby runtime, long value) {
+		return RubyFloat.newFloat(runtime, (double) value);
+	}
+	public static ByteList __int64_to_s(Ruby runtime, long value) {
+		return new ByteList(java.lang.Long.toString(value).getBytes(CHARSET_US_ASCII), USASCIIEncoding.INSTANCE);
+	}
+	public static ByteList __int64_to_hex(Ruby runtime, long value) {
+		int n = 020;
+		byte[] m = new byte[n];
+		while (true) {
+			n -= 1;
+			int c = (int) value & 0x0F;
+			m[n] = (byte) (c < 10 ? c + 0x30 : c + 0x41 - 10);
+			if (n == 0)
+				break;
+			value >>= 4;
+		}
+		return new ByteList(m, USASCIIEncoding.INSTANCE);
+	}
+	public static ByteList __int64_chr(Ruby runtime, long value) {
+		if (value < 0x00)
+			throw runtime.newRangeError("out of range");
+		if (value <= 0x7F)
+			return new ByteList(new byte[] { (byte) value }, USASCIIEncoding.INSTANCE);
+		if (value <= 0xFF)
+			return new ByteList(new byte[] { (byte) value }, ASCIIEncoding.INSTANCE);
+		throw runtime.newRangeError("out of range");
+	}
+	public static int __float32_hash(float value) {
+		return __int32_hash(java.lang.Float.floatToRawIntBits(value));
+	}
+	public static RubyInteger __float32_to_i(Ruby runtime, float value) {
+		if (Float.isNaN(value))
+			throw runtime.newFloatDomainError("NaN");
+		if (Float.isInfinite(value))
+			throw runtime.newFloatDomainError(value < 0 ? "-Infinity" : "Infinity");
+		if (value < RubyFixnum.MIN || value >= RubyFixnum.MAX)
+			return RubyBignum.newBignum(runtime, value);
+		return RubyFixnum.newFixnum(runtime, (long) value);
+	}
+	public static RubyFloat __float32_to_f(Ruby runtime, float value) {
+		return RubyFloat.newFloat(runtime, (double) value);
+	}
+	public static ByteList __float32_to_s(Ruby runtime, float value) {
+		return new ByteList(Float.toString(value).getBytes(CHARSET_US_ASCII), USASCIIEncoding.INSTANCE);
+	}
+	public static int __float64_hash(double value) {
+		return __int64_hash(java.lang.Double.doubleToRawLongBits(value));
+	}
+	public static RubyInteger __float64_to_i(Ruby runtime, double value) {
+		if (Double.isNaN(value))
+			throw runtime.newFloatDomainError("NaN");
+		if (Double.isInfinite(value))
+			throw runtime.newFloatDomainError(value < 0 ? "-Infinity" : "Infinity");
+		if (value < RubyFixnum.MIN || value >= RubyFixnum.MAX)
+			return RubyBignum.newBignum(runtime, value);
+		return RubyFixnum.newFixnum(runtime, (long) value);
+	}
+	public static RubyFloat __float64_to_f(Ruby runtime, double value) {
+		return RubyFloat.newFloat(runtime, (double) value);
+	}
+	public static ByteList __float64_to_s(Ruby runtime, double value) {
+		return new ByteList(Double.toString(value).getBytes(CHARSET_US_ASCII), USASCIIEncoding.INSTANCE);
+	}
+	public static class Byte extends RubyObject {
+		@JRubyMethod(name = "[]", meta = true)
+		public static Byte get(IRubyObject self, IRubyObject o) {
+			RubyClass klass = (RubyClass) self;
+			Ruby runtime = klass.getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Byte(klass, v);
+		}
+		final byte value;
+		public Byte(RubyClass klass, int value) {
+			super(klass);
+			this.value = (byte) value;
+			return;
+		}
+		@Override
+		public java.lang.Object toJava(java.lang.Class target) {
+			return value;
+		}
+		@JRubyMethod(name = "eql?")
+		public RubyBoolean is_eql(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			if (o instanceof Byte) {
+				byte v = ((Byte) o).value;
+				return RubyBoolean.newBoolean(runtime, value == v);
+			}
+			return RubyBoolean.newBoolean(runtime, false);
+		}
+		@JRubyMethod
+		public RubyFixnum hash() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) PrimitiveService.__int32_hash(value));
+		}
+		@JRubyMethod
+		public Byte to_byte() {
+			Ruby runtime = getRuntime();
+			return new Byte(PrimitiveService.ByteClass, (byte) value);
+		}
+		@JRubyMethod
+		public Char to_char() {
+			Ruby runtime = getRuntime();
+			return new Char(PrimitiveService.CharClass, (char) value);
+		}
+		@JRubyMethod
+		public Int16 to_int16() {
+			Ruby runtime = getRuntime();
+			return new Int16(PrimitiveService.Int16Class, (short) value);
+		}
+		@JRubyMethod
+		public Int32 to_int32() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod
+		public Int64 to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public Float32 to_float32() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, (float) value);
+		}
+		@JRubyMethod
+		public Float64 to_float64() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, (double) value);
+		}
+		@JRubyMethod
+		public RubyInteger as_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat as_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_int() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat to_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyString to_s() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_s(runtime, value));
+		}
+		@JRubyMethod
+		public RubyString inspect() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_s(runtime, value));
+		}
+		@JRubyMethod(name = "==")
+		public RubyBoolean eq(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value == v);
+		}
+		@JRubyMethod(name = "!=")
+		public RubyBoolean ne(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value != v);
+		}
+		@JRubyMethod(name = "+@")
+		public Int32 pos() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, +value);
+		}
+		@JRubyMethod(name = "-@")
+		public Int32 neg() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, -value);
+		}
+		@JRubyMethod(name = "*")
+		public Int32 mul(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value * v);
+		}
+		@JRubyMethod(name = "/")
+		public Int32 div(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, PrimitiveService.__int32_div(runtime, value, v));
+		}
+		@JRubyMethod(name = "%")
+		public Int32 mod(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, PrimitiveService.__int32_mod(runtime, value, v));
+		}
+		@JRubyMethod(name = "+")
+		public Int32 add(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value + v);
+		}
+		@JRubyMethod(name = "-")
+		public Int32 sub(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value - v);
+		}
+		@JRubyMethod(name = "<=>")
+		public Int32 cmp(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int value = this.value;
+			int v = PrimitiveService.__object_i32(runtime, o);
+			if (value < v)
+				return PrimitiveService.Int32_M1;
+			if (value > v)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod(name = "<")
+		public RubyBoolean lt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value < v);
+		}
+		@JRubyMethod(name = "<=")
+		public RubyBoolean le(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value <= v);
+		}
+		@JRubyMethod(name = ">=")
+		public RubyBoolean ge(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value >= v);
+		}
+		@JRubyMethod(name = ">")
+		public RubyBoolean gt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value > v);
+		}
+		@JRubyMethod(name = "~")
+		public Int32 inv() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, ~value);
+		}
+		@JRubyMethod(name = "<<")
+		public Int32 shl(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value << v);
+		}
+		@JRubyMethod(name = ">>")
+		public Int32 shr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value >> v);
+		}
+		@JRubyMethod(name = "ushr")
+		public Int32 ushr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value >>> v);
+		}
+		@JRubyMethod(name = "&")
+		public Int32 and(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value & v);
+		}
+		@JRubyMethod(name = "^")
+		public Int32 xor(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value ^ v);
+		}
+		@JRubyMethod(name = "|")
+		public Int32 or(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value | v);
+		}
+		@JRubyMethod(name = "zero?")
+		public RubyBoolean is_zero() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, value == 0);
+		}
+	}
+	public static class Char extends RubyObject {
+		@JRubyMethod(name = "[]", meta = true)
+		public static Char get(IRubyObject self, IRubyObject o) {
+			RubyClass klass = (RubyClass) self;
+			Ruby runtime = klass.getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Char(klass, v);
+		}
+		final char value;
+		public Char(RubyClass klass, int value) {
+			super(klass);
+			this.value = (char) value;
+			return;
+		}
+		@Override
+		public java.lang.Object toJava(java.lang.Class target) {
+			return value;
+		}
+		@JRubyMethod(name = "eql?")
+		public RubyBoolean is_eql(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			if (o instanceof Char) {
+				char v = ((Char) o).value;
+				return RubyBoolean.newBoolean(runtime, value == v);
+			}
+			return RubyBoolean.newBoolean(runtime, false);
+		}
+		@JRubyMethod
+		public RubyFixnum hash() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) PrimitiveService.__int32_hash(value));
+		}
+		@JRubyMethod
+		public Byte to_byte() {
+			Ruby runtime = getRuntime();
+			return new Byte(PrimitiveService.ByteClass, (byte) value);
+		}
+		@JRubyMethod
+		public Char to_char() {
+			Ruby runtime = getRuntime();
+			return new Char(PrimitiveService.CharClass, (char) value);
+		}
+		@JRubyMethod
+		public Int16 to_int16() {
+			Ruby runtime = getRuntime();
+			return new Int16(PrimitiveService.Int16Class, (short) value);
+		}
+		@JRubyMethod
+		public Int32 to_int32() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod
+		public Int64 to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public Float32 to_float32() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, (float) value);
+		}
+		@JRubyMethod
+		public Float64 to_float64() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, (double) value);
+		}
+		@JRubyMethod
+		public RubyInteger as_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat as_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_int() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat to_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyString to_s() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_s(runtime, value));
+		}
+		@JRubyMethod
+		public RubyString inspect() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_s(runtime, value));
+		}
+		@JRubyMethod(name = "==")
+		public RubyBoolean eq(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value == v);
+		}
+		@JRubyMethod(name = "!=")
+		public RubyBoolean ne(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value != v);
+		}
+		@JRubyMethod(name = "+@")
+		public Int32 pos() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, +value);
+		}
+		@JRubyMethod(name = "-@")
+		public Int32 neg() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, -value);
+		}
+		@JRubyMethod(name = "*")
+		public Int32 mul(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value * v);
+		}
+		@JRubyMethod(name = "/")
+		public Int32 div(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, PrimitiveService.__int32_div(runtime, value, v));
+		}
+		@JRubyMethod(name = "%")
+		public Int32 mod(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, PrimitiveService.__int32_mod(runtime, value, v));
+		}
+		@JRubyMethod(name = "+")
+		public Int32 add(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value + v);
+		}
+		@JRubyMethod(name = "-")
+		public Int32 sub(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value - v);
+		}
+		@JRubyMethod(name = "<=>")
+		public Int32 cmp(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int value = this.value;
+			int v = PrimitiveService.__object_i32(runtime, o);
+			if (value < v)
+				return PrimitiveService.Int32_M1;
+			if (value > v)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod(name = "<")
+		public RubyBoolean lt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value < v);
+		}
+		@JRubyMethod(name = "<=")
+		public RubyBoolean le(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value <= v);
+		}
+		@JRubyMethod(name = ">=")
+		public RubyBoolean ge(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value >= v);
+		}
+		@JRubyMethod(name = ">")
+		public RubyBoolean gt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value > v);
+		}
+		@JRubyMethod(name = "~")
+		public Int32 inv() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, ~value);
+		}
+		@JRubyMethod(name = "<<")
+		public Int32 shl(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value << v);
+		}
+		@JRubyMethod(name = ">>")
+		public Int32 shr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value >> v);
+		}
+		@JRubyMethod(name = "ushr")
+		public Int32 ushr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value >>> v);
+		}
+		@JRubyMethod(name = "&")
+		public Int32 and(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value & v);
+		}
+		@JRubyMethod(name = "^")
+		public Int32 xor(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value ^ v);
+		}
+		@JRubyMethod(name = "|")
+		public Int32 or(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value | v);
+		}
+		@JRubyMethod(name = "zero?")
+		public RubyBoolean is_zero() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, value == 0);
+		}
+	}
+	public static class Int16 extends RubyObject {
+		@JRubyMethod(name = "[]", meta = true)
+		public static Int16 get(IRubyObject self, IRubyObject o) {
+			RubyClass klass = (RubyClass) self;
+			Ruby runtime = klass.getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int16(klass, v);
+		}
+		final short value;
+		public Int16(RubyClass klass, int value) {
+			super(klass);
+			this.value = (short) value;
+			return;
+		}
+		@Override
+		public java.lang.Object toJava(java.lang.Class target) {
+			return value;
+		}
+		@JRubyMethod(name = "eql?")
+		public RubyBoolean is_eql(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			if (o instanceof Int16) {
+				short v = ((Int16) o).value;
+				return RubyBoolean.newBoolean(runtime, value == v);
+			}
+			return RubyBoolean.newBoolean(runtime, false);
+		}
+		@JRubyMethod
+		public RubyFixnum hash() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) PrimitiveService.__int32_hash(value));
+		}
+		@JRubyMethod
+		public Byte to_byte() {
+			Ruby runtime = getRuntime();
+			return new Byte(PrimitiveService.ByteClass, (byte) value);
+		}
+		@JRubyMethod
+		public Char to_char() {
+			Ruby runtime = getRuntime();
+			return new Char(PrimitiveService.CharClass, (char) value);
+		}
+		@JRubyMethod
+		public Int16 to_int16() {
+			Ruby runtime = getRuntime();
+			return new Int16(PrimitiveService.Int16Class, (short) value);
+		}
+		@JRubyMethod
+		public Int32 to_int32() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod
+		public Int64 to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public Float32 to_float32() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, (float) value);
+		}
+		@JRubyMethod
+		public Float64 to_float64() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, (double) value);
+		}
+		@JRubyMethod
+		public RubyInteger as_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat as_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_int() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat to_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyString to_s() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_s(runtime, value));
+		}
+		@JRubyMethod
+		public RubyString inspect() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_s(runtime, value));
+		}
+		@JRubyMethod(name = "==")
+		public RubyBoolean eq(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value == v);
+		}
+		@JRubyMethod(name = "!=")
+		public RubyBoolean ne(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value != v);
+		}
+		@JRubyMethod(name = "+@")
+		public Int32 pos() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, +value);
+		}
+		@JRubyMethod(name = "-@")
+		public Int32 neg() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, -value);
+		}
+		@JRubyMethod(name = "*")
+		public Int32 mul(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value * v);
+		}
+		@JRubyMethod(name = "/")
+		public Int32 div(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, PrimitiveService.__int32_div(runtime, value, v));
+		}
+		@JRubyMethod(name = "%")
+		public Int32 mod(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, PrimitiveService.__int32_mod(runtime, value, v));
+		}
+		@JRubyMethod(name = "+")
+		public Int32 add(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value + v);
+		}
+		@JRubyMethod(name = "-")
+		public Int32 sub(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value - v);
+		}
+		@JRubyMethod(name = "<=>")
+		public Int32 cmp(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int value = this.value;
+			int v = PrimitiveService.__object_i32(runtime, o);
+			if (value < v)
+				return PrimitiveService.Int32_M1;
+			if (value > v)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod(name = "<")
+		public RubyBoolean lt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value < v);
+		}
+		@JRubyMethod(name = "<=")
+		public RubyBoolean le(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value <= v);
+		}
+		@JRubyMethod(name = ">=")
+		public RubyBoolean ge(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value >= v);
+		}
+		@JRubyMethod(name = ">")
+		public RubyBoolean gt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value > v);
+		}
+		@JRubyMethod(name = "~")
+		public Int32 inv() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, ~value);
+		}
+		@JRubyMethod(name = "<<")
+		public Int32 shl(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value << v);
+		}
+		@JRubyMethod(name = ">>")
+		public Int32 shr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value >> v);
+		}
+		@JRubyMethod(name = "ushr")
+		public Int32 ushr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value >>> v);
+		}
+		@JRubyMethod(name = "&")
+		public Int32 and(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value & v);
+		}
+		@JRubyMethod(name = "^")
+		public Int32 xor(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value ^ v);
+		}
+		@JRubyMethod(name = "|")
+		public Int32 or(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value | v);
+		}
+		@JRubyMethod(name = "zero?")
+		public RubyBoolean is_zero() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, value == 0);
+		}
+	}
+	public static class Int32 extends RubyObject {
+		@JRubyMethod(name = "[]", meta = true)
+		public static Int32 get(IRubyObject self, IRubyObject o) {
+			RubyClass klass = (RubyClass) self;
+			Ruby runtime = klass.getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(klass, v);
+		}
+		final int value;
+		public Int32(RubyClass klass, int value) {
+			super(klass);
+			this.value = (int) value;
+			return;
+		}
+		@Override
+		public java.lang.Object toJava(java.lang.Class target) {
+			return value;
+		}
+		@JRubyMethod(name = "eql?")
+		public RubyBoolean is_eql(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			if (o instanceof Int32) {
+				int v = ((Int32) o).value;
+				return RubyBoolean.newBoolean(runtime, value == v);
+			}
+			return RubyBoolean.newBoolean(runtime, false);
+		}
+		@JRubyMethod
+		public RubyFixnum hash() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) PrimitiveService.__int32_hash(value));
+		}
+		@JRubyMethod
+		public Byte to_byte() {
+			Ruby runtime = getRuntime();
+			return new Byte(PrimitiveService.ByteClass, (byte) value);
+		}
+		@JRubyMethod
+		public Char to_char() {
+			Ruby runtime = getRuntime();
+			return new Char(PrimitiveService.CharClass, (char) value);
+		}
+		@JRubyMethod
+		public Int16 to_int16() {
+			Ruby runtime = getRuntime();
+			return new Int16(PrimitiveService.Int16Class, (short) value);
+		}
+		@JRubyMethod
+		public Int32 to_int32() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod
+		public Int64 to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public Float32 to_float32() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, (float) value);
+		}
+		@JRubyMethod
+		public Float64 to_float64() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, (double) value);
+		}
+		@JRubyMethod
+		public RubyInteger as_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat as_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_int() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat to_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyString to_s() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_s(runtime, value));
+		}
+		@JRubyMethod
+		public RubyString inspect() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_s(runtime, value));
+		}
+		@JRubyMethod(name = "==")
+		public RubyBoolean eq(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value == v);
+		}
+		@JRubyMethod(name = "!=")
+		public RubyBoolean ne(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value != v);
+		}
+		@JRubyMethod(name = "+@")
+		public Int32 pos() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, +value);
+		}
+		@JRubyMethod(name = "-@")
+		public Int32 neg() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, -value);
+		}
+		@JRubyMethod(name = "*")
+		public Int32 mul(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value * v);
+		}
+		@JRubyMethod(name = "/")
+		public Int32 div(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, PrimitiveService.__int32_div(runtime, value, v));
+		}
+		@JRubyMethod(name = "%")
+		public Int32 mod(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, PrimitiveService.__int32_mod(runtime, value, v));
+		}
+		@JRubyMethod(name = "+")
+		public Int32 add(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value + v);
+		}
+		@JRubyMethod(name = "-")
+		public Int32 sub(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value - v);
+		}
+		@JRubyMethod(name = "<=>")
+		public Int32 cmp(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int value = this.value;
+			int v = PrimitiveService.__object_i32(runtime, o);
+			if (value < v)
+				return PrimitiveService.Int32_M1;
+			if (value > v)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod(name = "<")
+		public RubyBoolean lt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value < v);
+		}
+		@JRubyMethod(name = "<=")
+		public RubyBoolean le(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value <= v);
+		}
+		@JRubyMethod(name = ">=")
+		public RubyBoolean ge(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value >= v);
+		}
+		@JRubyMethod(name = ">")
+		public RubyBoolean gt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value > v);
+		}
+		@JRubyMethod(name = "~")
+		public Int32 inv() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, ~value);
+		}
+		@JRubyMethod(name = "<<")
+		public Int32 shl(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value << v);
+		}
+		@JRubyMethod(name = ">>")
+		public Int32 shr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value >> v);
+		}
+		@JRubyMethod(name = "ushr")
+		public Int32 ushr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value >>> v);
+		}
+		@JRubyMethod(name = "&")
+		public Int32 and(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value & v);
+		}
+		@JRubyMethod(name = "^")
+		public Int32 xor(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value ^ v);
+		}
+		@JRubyMethod(name = "|")
+		public Int32 or(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, value | v);
+		}
+		@JRubyMethod(name = "zero?")
+		public RubyBoolean is_zero() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, value == 0);
+		}
+		@JRubyMethod(name = "to_int32!")
+		public Int32 bang_to_int32() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod(name = "to_int64!")
+		public Int64 bang_to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public RubyFixnum to_fixnum() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) value);
+		}
+		@JRubyMethod
+		public RubyFixnum new_fixnum() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) value);
+		}
+		@JRubyMethod
+		public RubyString to_hex() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_to_hex(runtime, value));
+		}
+		@JRubyMethod
+		public RubyString chr() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int32_chr(runtime, value));
+		}
+		@JRubyMethod
+		public Int32 rol(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, java.lang.Integer.rotateLeft(value, v));
+		}
+		@JRubyMethod
+		public Int32 ror(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int32(PrimitiveService.Int32Class, java.lang.Integer.rotateRight(value, v));
+		}
+		@JRubyMethod
+		public Int32 count() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, java.lang.Integer.bitCount(value));
+		}
+		@JRubyMethod
+		public Int32 signum() {
+			Ruby runtime = getRuntime();
+			int value = this.value;
+			if (value < 0)
+				return PrimitiveService.Int32_M1;
+			if (value > 0)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod
+		public IRubyObject times(Block block) {
+			Ruby runtime = getRuntime();
+			RubyClass klass = PrimitiveService.Int32Class;
+			ThreadContext context = runtime.getCurrentContext();
+			int value = this.value;
+			int i = 0;
+			while (i < value) {
+				block.call(context, new Int32(klass, i));
+				i += 1;
+			}
+			return runtime.getNil();
+		}
+		@JRubyMethod
+		public IRubyObject upto(IRubyObject o, Block block) {
+			Ruby runtime = getRuntime();
+			RubyClass klass = PrimitiveService.Int32Class;
+			ThreadContext context = runtime.getCurrentContext();
+			int i = this.value;
+			int v = (int) PrimitiveService.__object_i32(runtime, o);
+			if (i <= v) {
+				while (true) {
+					block.call(context, new Int32(klass, i));
+					if (i == v)
+						break;
+					i += 1;
+				}
+			}
+			return runtime.getNil();
+		}
+		@JRubyMethod
+		public IRubyObject downto(IRubyObject o, Block block) {
+			Ruby runtime = getRuntime();
+			RubyClass klass = PrimitiveService.Int32Class;
+			ThreadContext context = runtime.getCurrentContext();
+			int i = this.value;
+			int v = (int) PrimitiveService.__object_i32(runtime, o);
+			if (i >= v) {
+				while (true) {
+					block.call(context, new Int32(klass, i));
+					if (i == v)
+						break;
+					i -= 1;
+				}
+			}
+			return runtime.getNil();
+		}
+	}
+	public static class Int64 extends RubyObject {
+		@JRubyMethod(name = "[]", meta = true)
+		public static Int64 get(IRubyObject self, IRubyObject o) {
+			RubyClass klass = (RubyClass) self;
+			Ruby runtime = klass.getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(klass, v);
+		}
+		final long value;
+		public Int64(RubyClass klass, long value) {
+			super(klass);
+			this.value = (long) value;
+			return;
+		}
+		@Override
+		public java.lang.Object toJava(java.lang.Class target) {
+			return value;
+		}
+		@JRubyMethod(name = "eql?")
+		public RubyBoolean is_eql(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			if (o instanceof Int64) {
+				long v = ((Int64) o).value;
+				return RubyBoolean.newBoolean(runtime, value == v);
+			}
+			return RubyBoolean.newBoolean(runtime, false);
+		}
+		@JRubyMethod
+		public RubyFixnum hash() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) PrimitiveService.__int64_hash(value));
+		}
+		@JRubyMethod
+		public Byte to_byte() {
+			Ruby runtime = getRuntime();
+			return new Byte(PrimitiveService.ByteClass, (byte) value);
+		}
+		@JRubyMethod
+		public Char to_char() {
+			Ruby runtime = getRuntime();
+			return new Char(PrimitiveService.CharClass, (char) value);
+		}
+		@JRubyMethod
+		public Int16 to_int16() {
+			Ruby runtime = getRuntime();
+			return new Int16(PrimitiveService.Int16Class, (short) value);
+		}
+		@JRubyMethod
+		public Int32 to_int32() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod
+		public Int64 to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public Float32 to_float32() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, (float) value);
+		}
+		@JRubyMethod
+		public Float64 to_float64() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, (double) value);
+		}
+		@JRubyMethod
+		public RubyInteger as_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int64_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat as_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int64_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int64_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_int() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int64_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat to_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__int64_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyString to_s() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int64_to_s(runtime, value));
+		}
+		@JRubyMethod
+		public RubyString inspect() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int64_to_s(runtime, value));
+		}
+		@JRubyMethod(name = "==")
+		public RubyBoolean eq(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value == v);
+		}
+		@JRubyMethod(name = "!=")
+		public RubyBoolean ne(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value != v);
+		}
+		@JRubyMethod(name = "+@")
+		public Int64 pos() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, +value);
+		}
+		@JRubyMethod(name = "-@")
+		public Int64 neg() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, -value);
+		}
+		@JRubyMethod(name = "*")
+		public Int64 mul(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value * v);
+		}
+		@JRubyMethod(name = "/")
+		public Int64 div(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, PrimitiveService.__int64_div(runtime, value, v));
+		}
+		@JRubyMethod(name = "%")
+		public Int64 mod(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, PrimitiveService.__int64_mod(runtime, value, v));
+		}
+		@JRubyMethod(name = "+")
+		public Int64 add(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value + v);
+		}
+		@JRubyMethod(name = "-")
+		public Int64 sub(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value - v);
+		}
+		@JRubyMethod(name = "<=>")
+		public Int32 cmp(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long value = this.value;
+			long v = PrimitiveService.__object_i64(runtime, o);
+			if (value < v)
+				return PrimitiveService.Int32_M1;
+			if (value > v)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod(name = "<")
+		public RubyBoolean lt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value < v);
+		}
+		@JRubyMethod(name = "<=")
+		public RubyBoolean le(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value <= v);
+		}
+		@JRubyMethod(name = ">=")
+		public RubyBoolean ge(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value >= v);
+		}
+		@JRubyMethod(name = ">")
+		public RubyBoolean gt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value > v);
+		}
+		@JRubyMethod(name = "~")
+		public Int64 inv() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, ~value);
+		}
+		@JRubyMethod(name = "<<")
+		public Int64 shl(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value << v);
+		}
+		@JRubyMethod(name = ">>")
+		public Int64 shr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value >> v);
+		}
+		@JRubyMethod(name = "ushr")
+		public Int64 ushr(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value >>> v);
+		}
+		@JRubyMethod(name = "&")
+		public Int64 and(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value & v);
+		}
+		@JRubyMethod(name = "^")
+		public Int64 xor(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value ^ v);
+		}
+		@JRubyMethod(name = "|")
+		public Int64 or(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			long v = PrimitiveService.__object_i64(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, value | v);
+		}
+		@JRubyMethod(name = "zero?")
+		public RubyBoolean is_zero() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, value == 0);
+		}
+		@JRubyMethod(name = "to_int32!")
+		public Int32 bang_to_int32() {
+			Ruby runtime = getRuntime();
+			if (value < -0x80000000 || value > 0x7FFFFFFF)
+				throw runtime.newRangeError("int64 too big to convert to int32");
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod(name = "to_int64!")
+		public Int64 bang_to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public RubyFixnum to_fixnum() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) value);
+		}
+		@JRubyMethod
+		public RubyFixnum new_fixnum() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) value);
+		}
+		@JRubyMethod
+		public RubyString to_hex() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__int64_to_hex(runtime, value));
+		}
+		@JRubyMethod
+		public Int64 rol(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, java.lang.Long.rotateLeft(value, v));
+		}
+		@JRubyMethod
+		public Int64 ror(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			int v = PrimitiveService.__object_i32(runtime, o);
+			return new Int64(PrimitiveService.Int64Class, java.lang.Long.rotateRight(value, v));
+		}
+		@JRubyMethod
+		public Int32 count() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, java.lang.Long.bitCount(value));
+		}
+		@JRubyMethod
+		public Int32 signum() {
+			Ruby runtime = getRuntime();
+			long value = this.value;
+			if (value < 0)
+				return PrimitiveService.Int32_M1;
+			if (value > 0)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod
+		public IRubyObject times(Block block) {
+			Ruby runtime = getRuntime();
+			RubyClass klass = PrimitiveService.Int64Class;
+			ThreadContext context = runtime.getCurrentContext();
+			long value = this.value;
+			long i = 0;
+			while (i < value) {
+				block.call(context, new Int64(klass, i));
+				i += 1;
+			}
+			return runtime.getNil();
+		}
+	}
+	public static class Float32 extends RubyObject {
+		@JRubyMethod(name = "[]", meta = true)
+		public static Float32 get(IRubyObject self, IRubyObject o) {
+			RubyClass klass = (RubyClass) self;
+			Ruby runtime = klass.getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return new Float32(klass, v);
+		}
+		final float value;
+		public Float32(RubyClass klass, float value) {
+			super(klass);
+			this.value = (float) value;
+			return;
+		}
+		@Override
+		public java.lang.Object toJava(java.lang.Class target) {
+			return value;
+		}
+		@JRubyMethod(name = "eql?")
+		public RubyBoolean is_eql(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			if (o instanceof Float32) {
+				float v = ((Float32) o).value;
+				return RubyBoolean.newBoolean(runtime, value == v);
+			}
+			return RubyBoolean.newBoolean(runtime, false);
+		}
+		@JRubyMethod
+		public RubyFixnum hash() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) PrimitiveService.__float32_hash(value));
+		}
+		@JRubyMethod
+		public Byte to_byte() {
+			Ruby runtime = getRuntime();
+			return new Byte(PrimitiveService.ByteClass, (byte) value);
+		}
+		@JRubyMethod
+		public Char to_char() {
+			Ruby runtime = getRuntime();
+			return new Char(PrimitiveService.CharClass, (char) value);
+		}
+		@JRubyMethod
+		public Int16 to_int16() {
+			Ruby runtime = getRuntime();
+			return new Int16(PrimitiveService.Int16Class, (short) value);
+		}
+		@JRubyMethod
+		public Int32 to_int32() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod
+		public Int64 to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public Float32 to_float32() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, (float) value);
+		}
+		@JRubyMethod
+		public Float64 to_float64() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, (double) value);
+		}
+		@JRubyMethod
+		public RubyInteger as_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat as_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_int() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float32_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat to_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float32_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyString to_s() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__float32_to_s(runtime, value));
+		}
+		@JRubyMethod
+		public RubyString inspect() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__float32_to_s(runtime, value));
+		}
+		@JRubyMethod(name = "==")
+		public RubyBoolean eq(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value == v);
+		}
+		@JRubyMethod(name = "!=")
+		public RubyBoolean ne(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value != v);
+		}
+		@JRubyMethod(name = "+@")
+		public Float32 pos() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, +value);
+		}
+		@JRubyMethod(name = "-@")
+		public Float32 neg() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, -value);
+		}
+		@JRubyMethod(name = "*")
+		public Float32 mul(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return new Float32(PrimitiveService.Float32Class, value * v);
+		}
+		@JRubyMethod(name = "/")
+		public Float32 div(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return new Float32(PrimitiveService.Float32Class, PrimitiveService.__float32_div(runtime, value, v));
+		}
+		@JRubyMethod(name = "%")
+		public Float32 mod(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return new Float32(PrimitiveService.Float32Class, PrimitiveService.__float32_mod(runtime, value, v));
+		}
+		@JRubyMethod(name = "+")
+		public Float32 add(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return new Float32(PrimitiveService.Float32Class, value + v);
+		}
+		@JRubyMethod(name = "-")
+		public Float32 sub(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return new Float32(PrimitiveService.Float32Class, value - v);
+		}
+		@JRubyMethod(name = "<=>")
+		public Int32 cmp(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float value = this.value;
+			float v = PrimitiveService.__object_f32(runtime, o);
+			if (value < v)
+				return PrimitiveService.Int32_M1;
+			if (value > v)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod(name = "<")
+		public RubyBoolean lt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value < v);
+		}
+		@JRubyMethod(name = "<=")
+		public RubyBoolean le(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value <= v);
+		}
+		@JRubyMethod(name = ">=")
+		public RubyBoolean ge(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value >= v);
+		}
+		@JRubyMethod(name = ">")
+		public RubyBoolean gt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			float v = PrimitiveService.__object_f32(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value > v);
+		}
+		@JRubyMethod(name = "zero?")
+		public RubyBoolean is_zero() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, value == 0);
+		}
+		@JRubyMethod(name = "nan?")
+		public RubyBoolean is_nan() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, Float.isNaN(value));
+		}
+		@JRubyMethod(name = "infinite?")
+		public RubyBoolean is_infinite() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, Float.isInfinite(value));
+		}
+		@JRubyMethod(name = "finite?")
+		public RubyBoolean is_finite() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, !Float.isNaN(value) && !Float.isInfinite(value));
+		}
+	}
+	public static class Float64 extends RubyObject {
+		@JRubyMethod(name = "[]", meta = true)
+		public static Float64 get(IRubyObject self, IRubyObject o) {
+			RubyClass klass = (RubyClass) self;
+			Ruby runtime = klass.getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return new Float64(klass, v);
+		}
+		final double value;
+		public Float64(RubyClass klass, double value) {
+			super(klass);
+			this.value = (double) value;
+			return;
+		}
+		@Override
+		public java.lang.Object toJava(java.lang.Class target) {
+			return value;
+		}
+		@JRubyMethod(name = "eql?")
+		public RubyBoolean is_eql(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			if (o instanceof Float64) {
+				double v = ((Float64) o).value;
+				return RubyBoolean.newBoolean(runtime, value == v);
+			}
+			return RubyBoolean.newBoolean(runtime, false);
+		}
+		@JRubyMethod
+		public RubyFixnum hash() {
+			Ruby runtime = getRuntime();
+			return RubyFixnum.newFixnum(runtime, (long) PrimitiveService.__float64_hash(value));
+		}
+		@JRubyMethod
+		public Byte to_byte() {
+			Ruby runtime = getRuntime();
+			return new Byte(PrimitiveService.ByteClass, (byte) value);
+		}
+		@JRubyMethod
+		public Char to_char() {
+			Ruby runtime = getRuntime();
+			return new Char(PrimitiveService.CharClass, (char) value);
+		}
+		@JRubyMethod
+		public Int16 to_int16() {
+			Ruby runtime = getRuntime();
+			return new Int16(PrimitiveService.Int16Class, (short) value);
+		}
+		@JRubyMethod
+		public Int32 to_int32() {
+			Ruby runtime = getRuntime();
+			return new Int32(PrimitiveService.Int32Class, (int) value);
+		}
+		@JRubyMethod
+		public Int64 to_int64() {
+			Ruby runtime = getRuntime();
+			return new Int64(PrimitiveService.Int64Class, (long) value);
+		}
+		@JRubyMethod
+		public Float32 to_float32() {
+			Ruby runtime = getRuntime();
+			return new Float32(PrimitiveService.Float32Class, (float) value);
+		}
+		@JRubyMethod
+		public Float64 to_float64() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, (double) value);
+		}
+		@JRubyMethod
+		public RubyInteger as_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float64_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat as_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float64_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_i() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float64_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyInteger to_int() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float64_to_i(runtime, value);
+		}
+		@JRubyMethod
+		public RubyFloat to_f() {
+			Ruby runtime = getRuntime();
+			return PrimitiveService.__float64_to_f(runtime, value);
+		}
+		@JRubyMethod
+		public RubyString to_s() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__float64_to_s(runtime, value));
+		}
+		@JRubyMethod
+		public RubyString inspect() {
+			Ruby runtime = getRuntime();
+			return RubyString.newString(runtime, PrimitiveService.__float64_to_s(runtime, value));
+		}
+		@JRubyMethod(name = "==")
+		public RubyBoolean eq(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value == v);
+		}
+		@JRubyMethod(name = "!=")
+		public RubyBoolean ne(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value != v);
+		}
+		@JRubyMethod(name = "+@")
+		public Float64 pos() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, +value);
+		}
+		@JRubyMethod(name = "-@")
+		public Float64 neg() {
+			Ruby runtime = getRuntime();
+			return new Float64(PrimitiveService.Float64Class, -value);
+		}
+		@JRubyMethod(name = "*")
+		public Float64 mul(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return new Float64(PrimitiveService.Float64Class, value * v);
+		}
+		@JRubyMethod(name = "/")
+		public Float64 div(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return new Float64(PrimitiveService.Float64Class, PrimitiveService.__float64_div(runtime, value, v));
+		}
+		@JRubyMethod(name = "%")
+		public Float64 mod(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return new Float64(PrimitiveService.Float64Class, PrimitiveService.__float64_mod(runtime, value, v));
+		}
+		@JRubyMethod(name = "+")
+		public Float64 add(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return new Float64(PrimitiveService.Float64Class, value + v);
+		}
+		@JRubyMethod(name = "-")
+		public Float64 sub(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return new Float64(PrimitiveService.Float64Class, value - v);
+		}
+		@JRubyMethod(name = "<=>")
+		public Int32 cmp(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double value = this.value;
+			double v = PrimitiveService.__object_f64(runtime, o);
+			if (value < v)
+				return PrimitiveService.Int32_M1;
+			if (value > v)
+				return PrimitiveService.Int32_1;
+			return PrimitiveService.Int32_0;
+		}
+		@JRubyMethod(name = "<")
+		public RubyBoolean lt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value < v);
+		}
+		@JRubyMethod(name = "<=")
+		public RubyBoolean le(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value <= v);
+		}
+		@JRubyMethod(name = ">=")
+		public RubyBoolean ge(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value >= v);
+		}
+		@JRubyMethod(name = ">")
+		public RubyBoolean gt(IRubyObject o) {
+			Ruby runtime = getRuntime();
+			double v = PrimitiveService.__object_f64(runtime, o);
+			return RubyBoolean.newBoolean(runtime, value > v);
+		}
+		@JRubyMethod(name = "zero?")
+		public RubyBoolean is_zero() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, value == 0);
+		}
+		@JRubyMethod(name = "nan?")
+		public RubyBoolean is_nan() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, Double.isNaN(value));
+		}
+		@JRubyMethod(name = "infinite?")
+		public RubyBoolean is_infinite() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, Double.isInfinite(value));
+		}
+		@JRubyMethod(name = "finite?")
+		public RubyBoolean is_finite() {
+			Ruby runtime = getRuntime();
+			return RubyBoolean.newBoolean(runtime, !Double.isNaN(value) && !Double.isInfinite(value));
+		}
+	}
+	public boolean basicLoad(Ruby runtime) {
+		Integer_x8000000000000000 = RubyBignum.newBignum(runtime, new java.math.BigInteger("8000000000000000", 0x10));
+		Integer_xFFFFFFFFFFFFFFFF = RubyBignum.newBignum(runtime, new java.math.BigInteger("FFFFFFFFFFFFFFFF", 0x10));
+		Integer_xM8000000000000000 = RubyFixnum.newFixnum(runtime, -0x8000000000000000L);
+		RubyClass ObjectClass = runtime.getObject();
+		ByteClass = runtime.defineClass("Byte", ObjectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+		ByteClass.defineAnnotatedMethods(Byte.class);
+		CharClass = runtime.defineClass("Char", ObjectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+		CharClass.defineAnnotatedMethods(Char.class);
+		Int16Class = runtime.defineClass("Int16", ObjectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+		Int16Class.defineAnnotatedMethods(Int16.class);
+		Int32Class = runtime.defineClass("Int32", ObjectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+		Int32Class.defineAnnotatedMethods(Int32.class);
+		Int64Class = runtime.defineClass("Int64", ObjectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+		Int64Class.defineAnnotatedMethods(Int64.class);
+		Float32Class = runtime.defineClass("Float32", ObjectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+		Float32Class.defineAnnotatedMethods(Float32.class);
+		Float32Class.defineConstant("NEGATIVE_INFINITY", new Float32(Float32Class, java.lang.Float.NEGATIVE_INFINITY));
+		Float32Class.defineConstant("POSITIVE_INFINITY", new Float32(Float32Class, java.lang.Float.POSITIVE_INFINITY));
+		Float64Class = runtime.defineClass("Float64", ObjectClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+		Float64Class.defineAnnotatedMethods(Float64.class);
+		Float64Class.defineConstant("NEGATIVE_INFINITY", new Float64(Float64Class, java.lang.Float.NEGATIVE_INFINITY));
+		Float64Class.defineConstant("POSITIVE_INFINITY", new Float64(Float64Class, java.lang.Float.POSITIVE_INFINITY));
+		Int32_0 = new Int32(Int32Class, 0);
+		Int32_1 = new Int32(Int32Class, 1);
+		Int32_M1 = new Int32(Int32Class, -1);
+		return true;
+	}
+}