[jvm] cast all the things (#8776)

* [tests] generate numeric cast tests

* [jvm] embrace the madness

* [jvm] embrace even more madness

src/generators/jvm/jvmMethod.ml

@@ -393,56 +393,169 @@ class builder jc name jsig = object(self)
 	(** Casts the top of the stack to [jsig]. If [allow_to_string] is true, Jvm.toString is called. **)
 	method cast ?(not_null=false) ?(allow_to_string=false) jsig =
 		let jsig' = code#get_stack#top in
+		let is_number_sig except = function
+			| TObject((["java";"lang"],("Byte" | "Short" | "Integer" | "Long" | "Float" | "Double" as name)),_) when name <> except ->
+				true
+			| _ ->
+				false
+		in
+		let rec unboxed_to_byte () = match code#get_stack#top with
+			| TByte | TBool -> ()
+			| TChar | TShort | TInt ->
+				code#i2b TByte
+			| TLong ->
+				code#l2i;
+				unboxed_to_byte ();
+			| TFloat ->
+				code#f2i;
+				unboxed_to_byte ();
+			| TDouble ->
+				code#d2i;
+				unboxed_to_byte ();
+			| jsig ->
+				failwith (s_signature_kind jsig);
+		in
+		let rec unboxed_to_short () = match code#get_stack#top with
+			| TShort -> ()
+			| TBool | TByte | TChar | TInt ->
+				code#i2s;
+			| TLong ->
+				code#l2i;
+				unboxed_to_short ();
+			| TFloat ->
+				code#f2i;
+				unboxed_to_short ();
+			| TDouble ->
+				code#d2i;
+				unboxed_to_short ();
+			| _ ->
+				assert false
+		in
+		let rec unboxed_to_int () = match code#get_stack#top with
+			| TBool | TByte | TShort | TChar | TInt ->
+				ignore(code#get_stack#pop);
+				code#get_stack#push TInt;
+			| TLong ->
+				code#l2i;
+			| TFloat ->
+				code#f2i;
+			| TDouble ->
+				code#d2i;
+			| _ ->
+				assert false
+		in
+		let rec unboxed_to_long () = match code#get_stack#top with
+			| TBool | TByte | TShort | TChar | TInt ->
+				code#i2l;
+			| TLong ->
+				()
+			| TFloat ->
+				code#f2l;
+			| TDouble ->
+				code#d2l;
+			| _ ->
+				assert false
+		in
+		let rec unboxed_to_float () = match code#get_stack#top with
+			| TBool | TByte | TShort | TChar | TInt ->
+				code#i2f;
+			| TLong ->
+				code#l2f;
+			| TFloat ->
+				()
+			| TDouble ->
+				code#d2f;
+			| _ ->
+				assert false
+		in
+		let rec unboxed_to_double () = match code#get_stack#top with
+			| TBool | TByte | TShort | TChar | TInt ->
+				code#i2d;
+			| TLong ->
+				code#l2d;
+			| TFloat ->
+				code#f2d;
+			| TDouble ->
+				()
+			| _ ->
+				assert false
+		in
+		let get_conv = function
+			| "Byte" -> unboxed_to_byte
+			| "Short" -> unboxed_to_short
+			| "Integer" -> unboxed_to_int
+			| "Long" -> unboxed_to_long
+			| "Float" -> unboxed_to_float
+			| "Double" -> unboxed_to_double
+			| _ -> assert false
+		in
+		let number_to name =
+			let boxed_sig = TObject((["java";"lang"],name),[]) in
+			self#invokestatic (["haxe";"jvm"],"Jvm") ("numberTo" ^ name) (method_sig [number_sig] (Some boxed_sig))
+		in
+		let dynamic_to name =
+			let boxed_sig = TObject((["java";"lang"],name),[]) in
+			self#invokestatic (["haxe";"jvm"],"Jvm") ("dynamicTo" ^ name) (method_sig [object_sig] (Some boxed_sig))
+		in
+		let numeric_cast_boxed name jsig =
+			if is_unboxed jsig then begin
+				(get_conv name) ();
+				self#expect_reference_type
+			end else if is_number_sig name jsig then
+				number_to name
+			else if jsig = object_sig then
+				dynamic_to name
+			else
+				code#checkcast (["java";"lang"],name)
+		in
+		let numeric_cast_unboxed name jsig =
+			if is_unboxed jsig then
+				(get_conv name) ()
+			else begin
+				let unboxed_sig = get_unboxed_type (TObject((["java";"lang"],name),[])) in
+				self#expect_basic_type unboxed_sig;
+				(get_conv name) ()
+			end
+		in
 		begin match jsig,jsig' with
-		| TObject((["java";"lang"],"Double"),_),TInt ->
-			code#i2d;
-			self#expect_reference_type;
-		| TObject((["java";"lang"],"Double"),_),TObject((["java";"lang"],"Integer"),_) ->
-			self#invokestatic (["haxe";"jvm"],"Jvm") "nullIntToNullFloat" (method_sig [integer_sig] (Some double_sig))
-		| TObject((["java";"lang"],"Double"),_),TObject((["java";"lang"],"Object"),_) ->
-			self#invokestatic (["haxe";"jvm"],"Jvm") "dynamicToNullFloat" (method_sig [object_sig] (Some double_sig))
-		(* from double *)
-		| TFloat,TDouble ->
-			code#d2f
-		| TInt,TDouble ->
+		| TObject((["java";"lang"],"Byte"),_),jsig' ->
+			numeric_cast_boxed "Byte" jsig'
+		| TByte,jsig' ->
+			numeric_cast_unboxed "Byte" jsig'
+		| TObject((["java";"lang"],"Short"),_),jsig' ->
+			numeric_cast_boxed "Short" jsig'
+		| TShort,jsig' ->
+			numeric_cast_unboxed "Short" jsig'
+		| TObject((["java";"lang"],"Integer"),_),jsig' ->
+			numeric_cast_boxed "Integer" jsig'
+		| TInt,jsig' ->
+			numeric_cast_unboxed "Integer" jsig'
+		| TObject((["java";"lang"],"Long"),_),jsig' ->
+			numeric_cast_boxed "Long" jsig'
+		| TLong,jsig' ->
+			numeric_cast_unboxed "Long" jsig'
+		| TObject((["java";"lang"],"Float"),_),jsig' ->
+			numeric_cast_boxed "Float" jsig'
+		| TFloat,jsig' ->
+			numeric_cast_unboxed "Float" jsig'
+		| TObject((["java";"lang"],"Double"),_),jsig' ->
+			numeric_cast_boxed "Double" jsig'
+		| TDouble,jsig' ->
+			numeric_cast_unboxed "Double" jsig'
+		| TChar,TDouble ->
 			code#d2i;
-		| TLong,TDouble ->
-			code#d2l;
-		(* from float *)
-		| TDouble,TFloat ->
-			code#f2d
-		| TInt,TFloat ->
+			code#i2c;
+		| TChar,TFloat ->
 			code#f2i;
-		| TLong,TFloat ->
-			code#f2l;
-		(* from int *)
+			code#i2c;
+		| TChar,(TByte | TShort | TInt) ->
+			code#i2c;
+		| TChar,TLong ->
+			code#l2i;
+			code#i2c;
 		| TBool,TInt ->
 			ignore(code#get_stack#pop);
 			code#get_stack#push TBool;
-		| TByte,TInt ->
-			code#i2b TByte
-		| TChar,TInt ->
-			code#i2c
-		| TDouble,TInt ->
-			code#i2d;
-		| TFloat,TInt ->
-			code#i2f
-		| TLong,TInt ->
-			code#i2l;
-		| TShort,TInt ->
-			code#i2s
-		(* from long *)
-		| TDouble,TLong ->
-			code#l2d;
-		| TFloat,TLong ->
-			code#l2f
-		| TInt,TLong ->
-			code#l2i;
-		(* widening *)
-		| TInt,(TByte | TShort | TChar) ->
-			(* No cast, but rewrite stack top *)
-			ignore(code#get_stack#pop);
-			code#get_stack#push jsig;
 		| TObject(path1,_),TObject(path2,_) when path1 = path2 ->
 			()
 		| TObject((["java";"lang"],"String"),_),_ when allow_to_string ->

src/generators/jvm/jvmSignature.ml

@@ -229,6 +229,9 @@ module NativeSignatures = struct
 
 	(* numeric *)
 
+	let number_path = ["java";"lang"],"Number"
+	let number_sig = TObject(number_path,[])
+
 	let byte_path = ["java";"lang"],"Byte"
 	let byte_sig = TObject(byte_path,[])
 

std/jvm/Jvm.hx

@@ -127,7 +127,7 @@ class Jvm {
 				continue;
 			}
 			if (arg == (cast java.lang.Double.DoubleClass) && argType == cast java.lang.Integer.IntegerClass) {
-				callArgs[i] = nullIntToNullFloat(args[i]);
+				callArgs[i] = numberToDouble(args[i]);
 			} else {
 				return None;
 			}
@@ -145,23 +145,76 @@ class Jvm {
 
 	// casts
 
-	static public function dynamicToNullFloat<T>(d:T):Null<Float> {
-		if (instanceof(d, java.lang.Integer.IntegerClass)) {
-			return nullIntToNullFloat(cast d);
+	// TODO: add other dynamicToType methods
+
+	static public function dynamicToByte<T>(d:T):Null<java.lang.Byte> {
+		if (instanceof(d, java.lang.Number)) {
+			return numberToByte(cast d);
 		}
-		// TODO: need a better strategy to avoid infinite recursion here
 		return cast d;
 	}
 
-	static public function nullIntToNullFloat(i:Null<Int>):Null<Float> {
-		if (i == null) {
-			return null;
+	static public function dynamicToShort<T>(d:T):Null<java.lang.Short> {
+		if (instanceof(d, java.lang.Number)) {
+			return numberToShort(cast d);
+		}
+		return cast d;
+	}
+
+	static public function dynamicToInteger<T>(d:T):Null<Int> {
+		if (instanceof(d, java.lang.Number)) {
+			return numberToInteger(cast d);
+		}
+		return cast d;
+	}
+
+	static public function dynamicToLong<T>(d:T):Null<java.lang.Long> {
+		if (instanceof(d, java.lang.Number)) {
+			return numberToLong(cast d);
+		}
+		return cast d;
+	}
+
+	static public function dynamicToFloat<T>(d:T):Null<java.lang.Float> {
+		if (instanceof(d, java.lang.Number)) {
+			return numberToFloat(cast d);
 		}
-		return (cast i : java.lang.Number).intValue();
+		return cast d;
+	}
+
+	static public function dynamicToDouble<T>(d:T):Null<Float> {
+		if (instanceof(d, java.lang.Number)) {
+			return numberToDouble(cast d);
+		}
+		return cast d;
+	}
+
+	static public function numberToByte(n:java.lang.Number):Null<java.lang.Byte> {
+		return n == null ? null : n.byteValue();
+	}
+
+	static public function numberToShort(n:java.lang.Number):Null<java.lang.Short> {
+		return n == null ? null : n.shortValue();
+	}
+
+	static public function numberToInteger(n:java.lang.Number):Null<Int> {
+		return n == null ? null : n.intValue();
+	}
+
+	static public function numberToLong(n:java.lang.Number):Null<java.lang.Long> {
+		return n == null ? null : n.longValue();
+	}
+
+	static public function numberToFloat(n:java.lang.Number):Null<java.lang.Float> {
+		return n == null ? null : n.floatValue();
+	}
+
+	static public function numberToDouble(n:java.lang.Number):Null<Float> {
+		return n == null ? null : n.doubleValue();
 	}
 
 	static public function toByte(d:Dynamic) {
-		return d == null ? 0 : (d : java.lang.Byte).byteValue();
+		return d == null ? 0 : (d : java.lang.Number).byteValue();
 	}
 
 	static public function toChar(d:Dynamic) {
@@ -181,11 +234,11 @@ class Jvm {
 	}
 
 	static public function toLong(d:Dynamic) {
-		return d == null ? 0 : (d : java.lang.Long).longValue();
+		return d == null ? 0 : (d : java.lang.Number).longValue();
 	}
 
 	static public function toShort(d:Dynamic) {
-		return d == null ? 0 : (d : java.lang.Short).shortValue();
+		return d == null ? 0 : (d : java.lang.Number).shortValue();
 	}
 
 	static public function toBoolean(d:Dynamic) {

tests/unit/src/RunCastGenerator.hx

@@ -0,0 +1,106 @@
+import sys.io.File;
+import haxe.macro.Expr;
+import haxe.macro.Printer;
+
+class RunCastGenerator {
+	static function main() {
+		Sys.println("Starting cast generation...");
+		var td = macro class TestNumericCasts extends unit.Test {};
+		var intTypes = [macro:Int8, macro:Int16, macro:Int32, macro:Int64];
+		var floatTypes = [macro:Float32, macro:Float64];
+		var boxedIntTypes = [macro:Null<Int8>, macro:Null<Int16>, macro:Null<Int32>, macro:Null<Int64>];
+		var boxedFloatTypes = [macro:Null<Float32>, macro:Null<Float64>];
+		var allTypes = intTypes.concat(floatTypes).concat(boxedIntTypes).concat(boxedFloatTypes);
+		function getInfo(c:ComplexType) {
+			return switch (c) {
+				case macro:Int8: {nullable: false, floatable: false, name: "Int8"};
+				case macro:Int16: {nullable: false, floatable: false, name: "Int16"};
+				case macro:Int32: {nullable: false, floatable: false, name: "Int32"};
+				case macro:Int64: {nullable: false, floatable: false, name: "Int64"};
+				case macro:Float32: {nullable: false, floatable: true, name: "Float32"};
+				case macro:Float64: {nullable: false, floatable: true, name: "Float64"};
+				case macro:Null<Int8>: {nullable: true, floatable: false, name: "BoxedInt8"};
+				case macro:Null<Int16>: {nullable: true, floatable: false, name: "BoxedInt16"};
+				case macro:Null<Int32>: {nullable: true, floatable: false, name: "BoxedInt32"};
+				case macro:Null<Int64>: {nullable: true, floatable: false, name: "BoxedInt64"};
+				case macro:Null<Float32>: {nullable: true, floatable: true, name: "BoxedFloat32"};
+				case macro:Null<Float64>: {nullable: true, floatable: true, name: "BoxedFloat64"};
+				case _: throw false;
+			}
+		}
+		var tests = [];
+		for (typeFrom in allTypes) {
+			for (typeTo in allTypes) {
+				if (typeFrom == typeTo) {
+					continue;
+				}
+				var infoFrom = getInfo(typeFrom);
+				var infoTo = getInfo(typeTo);
+				var name = infoFrom.name + "_" + infoTo.name;
+				var dynamicName = "Dynamic" + name;
+				var fields = (macro class C {
+					static function $name(v : $typeFrom):$typeTo return cast v;
+					static function $dynamicName(v : $typeFrom):$typeTo {
+						var x:Dynamic = v;
+						return x;
+					}
+				}).fields;
+				td.fields.push(fields[0]);
+				td.fields.push(fields[1]);
+				function generateCalls(name:String) {
+					tests.push(macro deq(0, $i{name}(0)));
+					tests.push(macro deq(1, $i{name}(1)));
+					if (infoFrom.floatable) {
+						tests.push(macro deq(0., $i{name}(0.)));
+						tests.push(macro deq(1., $i{name}(1.)));
+					}
+					if (infoFrom.nullable) {
+						if (infoTo.nullable) {
+							tests.push(macro deq(null, $i{name}(null)));
+						} else {
+							tests.push(macro deq(CastHelper.nullOr0, $i{name}(null)));
+						}
+					}
+				}
+				generateCalls(name);
+				generateCalls(dynamicName);
+			}
+		}
+		td.fields = td.fields.concat((macro class C {
+			public function test() {
+				$b{tests};
+			}
+
+			function deq(expected:Dynamic, actual:Dynamic, ?p:haxe.PosInfos) {
+				eq(expected, actual, p);
+			}
+		}).fields);
+		var printer = new Printer();
+		var buffer = new StringBuf();
+		function line(content:String) {
+			buffer.add(content);
+			buffer.addChar("\n".code);
+		}
+		line("// This file is auto-generated from RunCastGenerator.hx - do not edit!");
+		line("package unit;");
+		line("#if java");
+		line("import java.StdTypes;");
+		line("private typedef Int32 = Int;");
+		line("private typedef Float32 = Single;");
+		line("private typedef Float64 = Float;");
+		line("#else");
+		line("private typedef Int8 = Int;");
+		line("private typedef Int16 = Int;");
+		line("private typedef Int32 = Int;");
+		line("private typedef Int64 = Int;");
+		line("private typedef Float32 = Float;");
+		line("private typedef Float64 = Float;");
+		line("#end");
+		line("private class CastHelper {");
+		line("\tstatic public var nullOr0 = #if target.static 0 #else null #end;");
+		line("}");
+		line(printer.printTypeDefinition(td));
+		File.saveContent("src/unit/TestNumericCasts.hx", buffer.toString());
+		Sys.println('Done with cast generation! " Generated ${td.fields.length} functions and ${tests.length} tests.');
+	}
+}

tests/unit/src/unit/TestMain.hx

@@ -71,6 +71,7 @@ class TestMain {
 			new TestCasts(),
 			new TestSyntaxModule(),
 			new TestNull(),
+			new TestNumericCasts(),
 			#if (!no_http && (!azure || !(php && Windows)))
 			new TestHttp(),
 			#end

tests/unit/src/unit/TestNumericCasts.hx

@@ -0,0 +1,1523 @@
+// This file is auto-generated from RunCastGenerator.hx - do not edit!
+package unit;
+#if java
+import java.StdTypes;
+private typedef Int32 = Int;
+private typedef Float32 = Single;
+private typedef Float64 = Float;
+#else
+private typedef Int8 = Int;
+private typedef Int16 = Int;
+private typedef Int32 = Int;
+private typedef Int64 = Int;
+private typedef Float32 = Float;
+private typedef Float64 = Float;
+#end
+private class CastHelper {
+	static public var nullOr0 = #if target.static 0 #else null #end;
+}
+class TestNumericCasts extends unit.Test {
+	static function Int8_Int16(v:Int8):Int16 return cast v;
+	static function DynamicInt8_Int16(v:Int8):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_Int32(v:Int8):Int32 return cast v;
+	static function DynamicInt8_Int32(v:Int8):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_Int64(v:Int8):Int64 return cast v;
+	static function DynamicInt8_Int64(v:Int8):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_Float32(v:Int8):Float32 return cast v;
+	static function DynamicInt8_Float32(v:Int8):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_Float64(v:Int8):Float64 return cast v;
+	static function DynamicInt8_Float64(v:Int8):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_BoxedInt8(v:Int8):Null<Int8> return cast v;
+	static function DynamicInt8_BoxedInt8(v:Int8):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_BoxedInt16(v:Int8):Null<Int16> return cast v;
+	static function DynamicInt8_BoxedInt16(v:Int8):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_BoxedInt32(v:Int8):Null<Int32> return cast v;
+	static function DynamicInt8_BoxedInt32(v:Int8):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_BoxedInt64(v:Int8):Null<Int64> return cast v;
+	static function DynamicInt8_BoxedInt64(v:Int8):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_BoxedFloat32(v:Int8):Null<Float32> return cast v;
+	static function DynamicInt8_BoxedFloat32(v:Int8):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int8_BoxedFloat64(v:Int8):Null<Float64> return cast v;
+	static function DynamicInt8_BoxedFloat64(v:Int8):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_Int8(v:Int16):Int8 return cast v;
+	static function DynamicInt16_Int8(v:Int16):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_Int32(v:Int16):Int32 return cast v;
+	static function DynamicInt16_Int32(v:Int16):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_Int64(v:Int16):Int64 return cast v;
+	static function DynamicInt16_Int64(v:Int16):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_Float32(v:Int16):Float32 return cast v;
+	static function DynamicInt16_Float32(v:Int16):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_Float64(v:Int16):Float64 return cast v;
+	static function DynamicInt16_Float64(v:Int16):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_BoxedInt8(v:Int16):Null<Int8> return cast v;
+	static function DynamicInt16_BoxedInt8(v:Int16):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_BoxedInt16(v:Int16):Null<Int16> return cast v;
+	static function DynamicInt16_BoxedInt16(v:Int16):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_BoxedInt32(v:Int16):Null<Int32> return cast v;
+	static function DynamicInt16_BoxedInt32(v:Int16):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_BoxedInt64(v:Int16):Null<Int64> return cast v;
+	static function DynamicInt16_BoxedInt64(v:Int16):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_BoxedFloat32(v:Int16):Null<Float32> return cast v;
+	static function DynamicInt16_BoxedFloat32(v:Int16):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int16_BoxedFloat64(v:Int16):Null<Float64> return cast v;
+	static function DynamicInt16_BoxedFloat64(v:Int16):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_Int8(v:Int32):Int8 return cast v;
+	static function DynamicInt32_Int8(v:Int32):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_Int16(v:Int32):Int16 return cast v;
+	static function DynamicInt32_Int16(v:Int32):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_Int64(v:Int32):Int64 return cast v;
+	static function DynamicInt32_Int64(v:Int32):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_Float32(v:Int32):Float32 return cast v;
+	static function DynamicInt32_Float32(v:Int32):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_Float64(v:Int32):Float64 return cast v;
+	static function DynamicInt32_Float64(v:Int32):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_BoxedInt8(v:Int32):Null<Int8> return cast v;
+	static function DynamicInt32_BoxedInt8(v:Int32):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_BoxedInt16(v:Int32):Null<Int16> return cast v;
+	static function DynamicInt32_BoxedInt16(v:Int32):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_BoxedInt32(v:Int32):Null<Int32> return cast v;
+	static function DynamicInt32_BoxedInt32(v:Int32):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_BoxedInt64(v:Int32):Null<Int64> return cast v;
+	static function DynamicInt32_BoxedInt64(v:Int32):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_BoxedFloat32(v:Int32):Null<Float32> return cast v;
+	static function DynamicInt32_BoxedFloat32(v:Int32):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int32_BoxedFloat64(v:Int32):Null<Float64> return cast v;
+	static function DynamicInt32_BoxedFloat64(v:Int32):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_Int8(v:Int64):Int8 return cast v;
+	static function DynamicInt64_Int8(v:Int64):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_Int16(v:Int64):Int16 return cast v;
+	static function DynamicInt64_Int16(v:Int64):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_Int32(v:Int64):Int32 return cast v;
+	static function DynamicInt64_Int32(v:Int64):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_Float32(v:Int64):Float32 return cast v;
+	static function DynamicInt64_Float32(v:Int64):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_Float64(v:Int64):Float64 return cast v;
+	static function DynamicInt64_Float64(v:Int64):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_BoxedInt8(v:Int64):Null<Int8> return cast v;
+	static function DynamicInt64_BoxedInt8(v:Int64):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_BoxedInt16(v:Int64):Null<Int16> return cast v;
+	static function DynamicInt64_BoxedInt16(v:Int64):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_BoxedInt32(v:Int64):Null<Int32> return cast v;
+	static function DynamicInt64_BoxedInt32(v:Int64):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_BoxedInt64(v:Int64):Null<Int64> return cast v;
+	static function DynamicInt64_BoxedInt64(v:Int64):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_BoxedFloat32(v:Int64):Null<Float32> return cast v;
+	static function DynamicInt64_BoxedFloat32(v:Int64):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Int64_BoxedFloat64(v:Int64):Null<Float64> return cast v;
+	static function DynamicInt64_BoxedFloat64(v:Int64):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_Int8(v:Float32):Int8 return cast v;
+	static function DynamicFloat32_Int8(v:Float32):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_Int16(v:Float32):Int16 return cast v;
+	static function DynamicFloat32_Int16(v:Float32):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_Int32(v:Float32):Int32 return cast v;
+	static function DynamicFloat32_Int32(v:Float32):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_Int64(v:Float32):Int64 return cast v;
+	static function DynamicFloat32_Int64(v:Float32):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_Float64(v:Float32):Float64 return cast v;
+	static function DynamicFloat32_Float64(v:Float32):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_BoxedInt8(v:Float32):Null<Int8> return cast v;
+	static function DynamicFloat32_BoxedInt8(v:Float32):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_BoxedInt16(v:Float32):Null<Int16> return cast v;
+	static function DynamicFloat32_BoxedInt16(v:Float32):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_BoxedInt32(v:Float32):Null<Int32> return cast v;
+	static function DynamicFloat32_BoxedInt32(v:Float32):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_BoxedInt64(v:Float32):Null<Int64> return cast v;
+	static function DynamicFloat32_BoxedInt64(v:Float32):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_BoxedFloat32(v:Float32):Null<Float32> return cast v;
+	static function DynamicFloat32_BoxedFloat32(v:Float32):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float32_BoxedFloat64(v:Float32):Null<Float64> return cast v;
+	static function DynamicFloat32_BoxedFloat64(v:Float32):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_Int8(v:Float64):Int8 return cast v;
+	static function DynamicFloat64_Int8(v:Float64):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_Int16(v:Float64):Int16 return cast v;
+	static function DynamicFloat64_Int16(v:Float64):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_Int32(v:Float64):Int32 return cast v;
+	static function DynamicFloat64_Int32(v:Float64):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_Int64(v:Float64):Int64 return cast v;
+	static function DynamicFloat64_Int64(v:Float64):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_Float32(v:Float64):Float32 return cast v;
+	static function DynamicFloat64_Float32(v:Float64):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_BoxedInt8(v:Float64):Null<Int8> return cast v;
+	static function DynamicFloat64_BoxedInt8(v:Float64):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_BoxedInt16(v:Float64):Null<Int16> return cast v;
+	static function DynamicFloat64_BoxedInt16(v:Float64):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_BoxedInt32(v:Float64):Null<Int32> return cast v;
+	static function DynamicFloat64_BoxedInt32(v:Float64):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_BoxedInt64(v:Float64):Null<Int64> return cast v;
+	static function DynamicFloat64_BoxedInt64(v:Float64):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_BoxedFloat32(v:Float64):Null<Float32> return cast v;
+	static function DynamicFloat64_BoxedFloat32(v:Float64):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function Float64_BoxedFloat64(v:Float64):Null<Float64> return cast v;
+	static function DynamicFloat64_BoxedFloat64(v:Float64):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_Int8(v:Null<Int8>):Int8 return cast v;
+	static function DynamicBoxedInt8_Int8(v:Null<Int8>):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_Int16(v:Null<Int8>):Int16 return cast v;
+	static function DynamicBoxedInt8_Int16(v:Null<Int8>):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_Int32(v:Null<Int8>):Int32 return cast v;
+	static function DynamicBoxedInt8_Int32(v:Null<Int8>):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_Int64(v:Null<Int8>):Int64 return cast v;
+	static function DynamicBoxedInt8_Int64(v:Null<Int8>):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_Float32(v:Null<Int8>):Float32 return cast v;
+	static function DynamicBoxedInt8_Float32(v:Null<Int8>):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_Float64(v:Null<Int8>):Float64 return cast v;
+	static function DynamicBoxedInt8_Float64(v:Null<Int8>):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_BoxedInt16(v:Null<Int8>):Null<Int16> return cast v;
+	static function DynamicBoxedInt8_BoxedInt16(v:Null<Int8>):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_BoxedInt32(v:Null<Int8>):Null<Int32> return cast v;
+	static function DynamicBoxedInt8_BoxedInt32(v:Null<Int8>):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_BoxedInt64(v:Null<Int8>):Null<Int64> return cast v;
+	static function DynamicBoxedInt8_BoxedInt64(v:Null<Int8>):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_BoxedFloat32(v:Null<Int8>):Null<Float32> return cast v;
+	static function DynamicBoxedInt8_BoxedFloat32(v:Null<Int8>):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt8_BoxedFloat64(v:Null<Int8>):Null<Float64> return cast v;
+	static function DynamicBoxedInt8_BoxedFloat64(v:Null<Int8>):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_Int8(v:Null<Int16>):Int8 return cast v;
+	static function DynamicBoxedInt16_Int8(v:Null<Int16>):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_Int16(v:Null<Int16>):Int16 return cast v;
+	static function DynamicBoxedInt16_Int16(v:Null<Int16>):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_Int32(v:Null<Int16>):Int32 return cast v;
+	static function DynamicBoxedInt16_Int32(v:Null<Int16>):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_Int64(v:Null<Int16>):Int64 return cast v;
+	static function DynamicBoxedInt16_Int64(v:Null<Int16>):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_Float32(v:Null<Int16>):Float32 return cast v;
+	static function DynamicBoxedInt16_Float32(v:Null<Int16>):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_Float64(v:Null<Int16>):Float64 return cast v;
+	static function DynamicBoxedInt16_Float64(v:Null<Int16>):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_BoxedInt8(v:Null<Int16>):Null<Int8> return cast v;
+	static function DynamicBoxedInt16_BoxedInt8(v:Null<Int16>):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_BoxedInt32(v:Null<Int16>):Null<Int32> return cast v;
+	static function DynamicBoxedInt16_BoxedInt32(v:Null<Int16>):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_BoxedInt64(v:Null<Int16>):Null<Int64> return cast v;
+	static function DynamicBoxedInt16_BoxedInt64(v:Null<Int16>):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_BoxedFloat32(v:Null<Int16>):Null<Float32> return cast v;
+	static function DynamicBoxedInt16_BoxedFloat32(v:Null<Int16>):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt16_BoxedFloat64(v:Null<Int16>):Null<Float64> return cast v;
+	static function DynamicBoxedInt16_BoxedFloat64(v:Null<Int16>):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_Int8(v:Null<Int32>):Int8 return cast v;
+	static function DynamicBoxedInt32_Int8(v:Null<Int32>):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_Int16(v:Null<Int32>):Int16 return cast v;
+	static function DynamicBoxedInt32_Int16(v:Null<Int32>):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_Int32(v:Null<Int32>):Int32 return cast v;
+	static function DynamicBoxedInt32_Int32(v:Null<Int32>):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_Int64(v:Null<Int32>):Int64 return cast v;
+	static function DynamicBoxedInt32_Int64(v:Null<Int32>):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_Float32(v:Null<Int32>):Float32 return cast v;
+	static function DynamicBoxedInt32_Float32(v:Null<Int32>):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_Float64(v:Null<Int32>):Float64 return cast v;
+	static function DynamicBoxedInt32_Float64(v:Null<Int32>):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_BoxedInt8(v:Null<Int32>):Null<Int8> return cast v;
+	static function DynamicBoxedInt32_BoxedInt8(v:Null<Int32>):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_BoxedInt16(v:Null<Int32>):Null<Int16> return cast v;
+	static function DynamicBoxedInt32_BoxedInt16(v:Null<Int32>):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_BoxedInt64(v:Null<Int32>):Null<Int64> return cast v;
+	static function DynamicBoxedInt32_BoxedInt64(v:Null<Int32>):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_BoxedFloat32(v:Null<Int32>):Null<Float32> return cast v;
+	static function DynamicBoxedInt32_BoxedFloat32(v:Null<Int32>):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt32_BoxedFloat64(v:Null<Int32>):Null<Float64> return cast v;
+	static function DynamicBoxedInt32_BoxedFloat64(v:Null<Int32>):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_Int8(v:Null<Int64>):Int8 return cast v;
+	static function DynamicBoxedInt64_Int8(v:Null<Int64>):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_Int16(v:Null<Int64>):Int16 return cast v;
+	static function DynamicBoxedInt64_Int16(v:Null<Int64>):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_Int32(v:Null<Int64>):Int32 return cast v;
+	static function DynamicBoxedInt64_Int32(v:Null<Int64>):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_Int64(v:Null<Int64>):Int64 return cast v;
+	static function DynamicBoxedInt64_Int64(v:Null<Int64>):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_Float32(v:Null<Int64>):Float32 return cast v;
+	static function DynamicBoxedInt64_Float32(v:Null<Int64>):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_Float64(v:Null<Int64>):Float64 return cast v;
+	static function DynamicBoxedInt64_Float64(v:Null<Int64>):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_BoxedInt8(v:Null<Int64>):Null<Int8> return cast v;
+	static function DynamicBoxedInt64_BoxedInt8(v:Null<Int64>):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_BoxedInt16(v:Null<Int64>):Null<Int16> return cast v;
+	static function DynamicBoxedInt64_BoxedInt16(v:Null<Int64>):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_BoxedInt32(v:Null<Int64>):Null<Int32> return cast v;
+	static function DynamicBoxedInt64_BoxedInt32(v:Null<Int64>):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_BoxedFloat32(v:Null<Int64>):Null<Float32> return cast v;
+	static function DynamicBoxedInt64_BoxedFloat32(v:Null<Int64>):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedInt64_BoxedFloat64(v:Null<Int64>):Null<Float64> return cast v;
+	static function DynamicBoxedInt64_BoxedFloat64(v:Null<Int64>):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_Int8(v:Null<Float32>):Int8 return cast v;
+	static function DynamicBoxedFloat32_Int8(v:Null<Float32>):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_Int16(v:Null<Float32>):Int16 return cast v;
+	static function DynamicBoxedFloat32_Int16(v:Null<Float32>):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_Int32(v:Null<Float32>):Int32 return cast v;
+	static function DynamicBoxedFloat32_Int32(v:Null<Float32>):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_Int64(v:Null<Float32>):Int64 return cast v;
+	static function DynamicBoxedFloat32_Int64(v:Null<Float32>):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_Float32(v:Null<Float32>):Float32 return cast v;
+	static function DynamicBoxedFloat32_Float32(v:Null<Float32>):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_Float64(v:Null<Float32>):Float64 return cast v;
+	static function DynamicBoxedFloat32_Float64(v:Null<Float32>):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_BoxedInt8(v:Null<Float32>):Null<Int8> return cast v;
+	static function DynamicBoxedFloat32_BoxedInt8(v:Null<Float32>):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_BoxedInt16(v:Null<Float32>):Null<Int16> return cast v;
+	static function DynamicBoxedFloat32_BoxedInt16(v:Null<Float32>):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_BoxedInt32(v:Null<Float32>):Null<Int32> return cast v;
+	static function DynamicBoxedFloat32_BoxedInt32(v:Null<Float32>):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_BoxedInt64(v:Null<Float32>):Null<Int64> return cast v;
+	static function DynamicBoxedFloat32_BoxedInt64(v:Null<Float32>):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat32_BoxedFloat64(v:Null<Float32>):Null<Float64> return cast v;
+	static function DynamicBoxedFloat32_BoxedFloat64(v:Null<Float32>):Null<Float64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_Int8(v:Null<Float64>):Int8 return cast v;
+	static function DynamicBoxedFloat64_Int8(v:Null<Float64>):Int8 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_Int16(v:Null<Float64>):Int16 return cast v;
+	static function DynamicBoxedFloat64_Int16(v:Null<Float64>):Int16 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_Int32(v:Null<Float64>):Int32 return cast v;
+	static function DynamicBoxedFloat64_Int32(v:Null<Float64>):Int32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_Int64(v:Null<Float64>):Int64 return cast v;
+	static function DynamicBoxedFloat64_Int64(v:Null<Float64>):Int64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_Float32(v:Null<Float64>):Float32 return cast v;
+	static function DynamicBoxedFloat64_Float32(v:Null<Float64>):Float32 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_Float64(v:Null<Float64>):Float64 return cast v;
+	static function DynamicBoxedFloat64_Float64(v:Null<Float64>):Float64 {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_BoxedInt8(v:Null<Float64>):Null<Int8> return cast v;
+	static function DynamicBoxedFloat64_BoxedInt8(v:Null<Float64>):Null<Int8> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_BoxedInt16(v:Null<Float64>):Null<Int16> return cast v;
+	static function DynamicBoxedFloat64_BoxedInt16(v:Null<Float64>):Null<Int16> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_BoxedInt32(v:Null<Float64>):Null<Int32> return cast v;
+	static function DynamicBoxedFloat64_BoxedInt32(v:Null<Float64>):Null<Int32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_BoxedInt64(v:Null<Float64>):Null<Int64> return cast v;
+	static function DynamicBoxedFloat64_BoxedInt64(v:Null<Float64>):Null<Int64> {
+		var x:Dynamic = v;
+		return x;
+	}
+	static function BoxedFloat64_BoxedFloat32(v:Null<Float64>):Null<Float32> return cast v;
+	static function DynamicBoxedFloat64_BoxedFloat32(v:Null<Float64>):Null<Float32> {
+		var x:Dynamic = v;
+		return x;
+	}
+	public function test() {
+		{
+			deq(0, Int8_Int16(0));
+			deq(1, Int8_Int16(1));
+			deq(0, DynamicInt8_Int16(0));
+			deq(1, DynamicInt8_Int16(1));
+			deq(0, Int8_Int32(0));
+			deq(1, Int8_Int32(1));
+			deq(0, DynamicInt8_Int32(0));
+			deq(1, DynamicInt8_Int32(1));
+			deq(0, Int8_Int64(0));
+			deq(1, Int8_Int64(1));
+			deq(0, DynamicInt8_Int64(0));
+			deq(1, DynamicInt8_Int64(1));
+			deq(0, Int8_Float32(0));
+			deq(1, Int8_Float32(1));
+			deq(0, DynamicInt8_Float32(0));
+			deq(1, DynamicInt8_Float32(1));
+			deq(0, Int8_Float64(0));
+			deq(1, Int8_Float64(1));
+			deq(0, DynamicInt8_Float64(0));
+			deq(1, DynamicInt8_Float64(1));
+			deq(0, Int8_BoxedInt8(0));
+			deq(1, Int8_BoxedInt8(1));
+			deq(0, DynamicInt8_BoxedInt8(0));
+			deq(1, DynamicInt8_BoxedInt8(1));
+			deq(0, Int8_BoxedInt16(0));
+			deq(1, Int8_BoxedInt16(1));
+			deq(0, DynamicInt8_BoxedInt16(0));
+			deq(1, DynamicInt8_BoxedInt16(1));
+			deq(0, Int8_BoxedInt32(0));
+			deq(1, Int8_BoxedInt32(1));
+			deq(0, DynamicInt8_BoxedInt32(0));
+			deq(1, DynamicInt8_BoxedInt32(1));
+			deq(0, Int8_BoxedInt64(0));
+			deq(1, Int8_BoxedInt64(1));
+			deq(0, DynamicInt8_BoxedInt64(0));
+			deq(1, DynamicInt8_BoxedInt64(1));
+			deq(0, Int8_BoxedFloat32(0));
+			deq(1, Int8_BoxedFloat32(1));
+			deq(0, DynamicInt8_BoxedFloat32(0));
+			deq(1, DynamicInt8_BoxedFloat32(1));
+			deq(0, Int8_BoxedFloat64(0));
+			deq(1, Int8_BoxedFloat64(1));
+			deq(0, DynamicInt8_BoxedFloat64(0));
+			deq(1, DynamicInt8_BoxedFloat64(1));
+			deq(0, Int16_Int8(0));
+			deq(1, Int16_Int8(1));
+			deq(0, DynamicInt16_Int8(0));
+			deq(1, DynamicInt16_Int8(1));
+			deq(0, Int16_Int32(0));
+			deq(1, Int16_Int32(1));
+			deq(0, DynamicInt16_Int32(0));
+			deq(1, DynamicInt16_Int32(1));
+			deq(0, Int16_Int64(0));
+			deq(1, Int16_Int64(1));
+			deq(0, DynamicInt16_Int64(0));
+			deq(1, DynamicInt16_Int64(1));
+			deq(0, Int16_Float32(0));
+			deq(1, Int16_Float32(1));
+			deq(0, DynamicInt16_Float32(0));
+			deq(1, DynamicInt16_Float32(1));
+			deq(0, Int16_Float64(0));
+			deq(1, Int16_Float64(1));
+			deq(0, DynamicInt16_Float64(0));
+			deq(1, DynamicInt16_Float64(1));
+			deq(0, Int16_BoxedInt8(0));
+			deq(1, Int16_BoxedInt8(1));
+			deq(0, DynamicInt16_BoxedInt8(0));
+			deq(1, DynamicInt16_BoxedInt8(1));
+			deq(0, Int16_BoxedInt16(0));
+			deq(1, Int16_BoxedInt16(1));
+			deq(0, DynamicInt16_BoxedInt16(0));
+			deq(1, DynamicInt16_BoxedInt16(1));
+			deq(0, Int16_BoxedInt32(0));
+			deq(1, Int16_BoxedInt32(1));
+			deq(0, DynamicInt16_BoxedInt32(0));
+			deq(1, DynamicInt16_BoxedInt32(1));
+			deq(0, Int16_BoxedInt64(0));
+			deq(1, Int16_BoxedInt64(1));
+			deq(0, DynamicInt16_BoxedInt64(0));
+			deq(1, DynamicInt16_BoxedInt64(1));
+			deq(0, Int16_BoxedFloat32(0));
+			deq(1, Int16_BoxedFloat32(1));
+			deq(0, DynamicInt16_BoxedFloat32(0));
+			deq(1, DynamicInt16_BoxedFloat32(1));
+			deq(0, Int16_BoxedFloat64(0));
+			deq(1, Int16_BoxedFloat64(1));
+			deq(0, DynamicInt16_BoxedFloat64(0));
+			deq(1, DynamicInt16_BoxedFloat64(1));
+			deq(0, Int32_Int8(0));
+			deq(1, Int32_Int8(1));
+			deq(0, DynamicInt32_Int8(0));
+			deq(1, DynamicInt32_Int8(1));
+			deq(0, Int32_Int16(0));
+			deq(1, Int32_Int16(1));
+			deq(0, DynamicInt32_Int16(0));
+			deq(1, DynamicInt32_Int16(1));
+			deq(0, Int32_Int64(0));
+			deq(1, Int32_Int64(1));
+			deq(0, DynamicInt32_Int64(0));
+			deq(1, DynamicInt32_Int64(1));
+			deq(0, Int32_Float32(0));
+			deq(1, Int32_Float32(1));
+			deq(0, DynamicInt32_Float32(0));
+			deq(1, DynamicInt32_Float32(1));
+			deq(0, Int32_Float64(0));
+			deq(1, Int32_Float64(1));
+			deq(0, DynamicInt32_Float64(0));
+			deq(1, DynamicInt32_Float64(1));
+			deq(0, Int32_BoxedInt8(0));
+			deq(1, Int32_BoxedInt8(1));
+			deq(0, DynamicInt32_BoxedInt8(0));
+			deq(1, DynamicInt32_BoxedInt8(1));
+			deq(0, Int32_BoxedInt16(0));
+			deq(1, Int32_BoxedInt16(1));
+			deq(0, DynamicInt32_BoxedInt16(0));
+			deq(1, DynamicInt32_BoxedInt16(1));
+			deq(0, Int32_BoxedInt32(0));
+			deq(1, Int32_BoxedInt32(1));
+			deq(0, DynamicInt32_BoxedInt32(0));
+			deq(1, DynamicInt32_BoxedInt32(1));
+			deq(0, Int32_BoxedInt64(0));
+			deq(1, Int32_BoxedInt64(1));
+			deq(0, DynamicInt32_BoxedInt64(0));
+			deq(1, DynamicInt32_BoxedInt64(1));
+			deq(0, Int32_BoxedFloat32(0));
+			deq(1, Int32_BoxedFloat32(1));
+			deq(0, DynamicInt32_BoxedFloat32(0));
+			deq(1, DynamicInt32_BoxedFloat32(1));
+			deq(0, Int32_BoxedFloat64(0));
+			deq(1, Int32_BoxedFloat64(1));
+			deq(0, DynamicInt32_BoxedFloat64(0));
+			deq(1, DynamicInt32_BoxedFloat64(1));
+			deq(0, Int64_Int8(0));
+			deq(1, Int64_Int8(1));
+			deq(0, DynamicInt64_Int8(0));
+			deq(1, DynamicInt64_Int8(1));
+			deq(0, Int64_Int16(0));
+			deq(1, Int64_Int16(1));
+			deq(0, DynamicInt64_Int16(0));
+			deq(1, DynamicInt64_Int16(1));
+			deq(0, Int64_Int32(0));
+			deq(1, Int64_Int32(1));
+			deq(0, DynamicInt64_Int32(0));
+			deq(1, DynamicInt64_Int32(1));
+			deq(0, Int64_Float32(0));
+			deq(1, Int64_Float32(1));
+			deq(0, DynamicInt64_Float32(0));
+			deq(1, DynamicInt64_Float32(1));
+			deq(0, Int64_Float64(0));
+			deq(1, Int64_Float64(1));
+			deq(0, DynamicInt64_Float64(0));
+			deq(1, DynamicInt64_Float64(1));
+			deq(0, Int64_BoxedInt8(0));
+			deq(1, Int64_BoxedInt8(1));
+			deq(0, DynamicInt64_BoxedInt8(0));
+			deq(1, DynamicInt64_BoxedInt8(1));
+			deq(0, Int64_BoxedInt16(0));
+			deq(1, Int64_BoxedInt16(1));
+			deq(0, DynamicInt64_BoxedInt16(0));
+			deq(1, DynamicInt64_BoxedInt16(1));
+			deq(0, Int64_BoxedInt32(0));
+			deq(1, Int64_BoxedInt32(1));
+			deq(0, DynamicInt64_BoxedInt32(0));
+			deq(1, DynamicInt64_BoxedInt32(1));
+			deq(0, Int64_BoxedInt64(0));
+			deq(1, Int64_BoxedInt64(1));
+			deq(0, DynamicInt64_BoxedInt64(0));
+			deq(1, DynamicInt64_BoxedInt64(1));
+			deq(0, Int64_BoxedFloat32(0));
+			deq(1, Int64_BoxedFloat32(1));
+			deq(0, DynamicInt64_BoxedFloat32(0));
+			deq(1, DynamicInt64_BoxedFloat32(1));
+			deq(0, Int64_BoxedFloat64(0));
+			deq(1, Int64_BoxedFloat64(1));
+			deq(0, DynamicInt64_BoxedFloat64(0));
+			deq(1, DynamicInt64_BoxedFloat64(1));
+			deq(0, Float32_Int8(0));
+			deq(1, Float32_Int8(1));
+			deq(0., Float32_Int8(0.));
+			deq(1., Float32_Int8(1.));
+			deq(0, DynamicFloat32_Int8(0));
+			deq(1, DynamicFloat32_Int8(1));
+			deq(0., DynamicFloat32_Int8(0.));
+			deq(1., DynamicFloat32_Int8(1.));
+			deq(0, Float32_Int16(0));
+			deq(1, Float32_Int16(1));
+			deq(0., Float32_Int16(0.));
+			deq(1., Float32_Int16(1.));
+			deq(0, DynamicFloat32_Int16(0));
+			deq(1, DynamicFloat32_Int16(1));
+			deq(0., DynamicFloat32_Int16(0.));
+			deq(1., DynamicFloat32_Int16(1.));
+			deq(0, Float32_Int32(0));
+			deq(1, Float32_Int32(1));
+			deq(0., Float32_Int32(0.));
+			deq(1., Float32_Int32(1.));
+			deq(0, DynamicFloat32_Int32(0));
+			deq(1, DynamicFloat32_Int32(1));
+			deq(0., DynamicFloat32_Int32(0.));
+			deq(1., DynamicFloat32_Int32(1.));
+			deq(0, Float32_Int64(0));
+			deq(1, Float32_Int64(1));
+			deq(0., Float32_Int64(0.));
+			deq(1., Float32_Int64(1.));
+			deq(0, DynamicFloat32_Int64(0));
+			deq(1, DynamicFloat32_Int64(1));
+			deq(0., DynamicFloat32_Int64(0.));
+			deq(1., DynamicFloat32_Int64(1.));
+			deq(0, Float32_Float64(0));
+			deq(1, Float32_Float64(1));
+			deq(0., Float32_Float64(0.));
+			deq(1., Float32_Float64(1.));
+			deq(0, DynamicFloat32_Float64(0));
+			deq(1, DynamicFloat32_Float64(1));
+			deq(0., DynamicFloat32_Float64(0.));
+			deq(1., DynamicFloat32_Float64(1.));
+			deq(0, Float32_BoxedInt8(0));
+			deq(1, Float32_BoxedInt8(1));
+			deq(0., Float32_BoxedInt8(0.));
+			deq(1., Float32_BoxedInt8(1.));
+			deq(0, DynamicFloat32_BoxedInt8(0));
+			deq(1, DynamicFloat32_BoxedInt8(1));
+			deq(0., DynamicFloat32_BoxedInt8(0.));
+			deq(1., DynamicFloat32_BoxedInt8(1.));
+			deq(0, Float32_BoxedInt16(0));
+			deq(1, Float32_BoxedInt16(1));
+			deq(0., Float32_BoxedInt16(0.));
+			deq(1., Float32_BoxedInt16(1.));
+			deq(0, DynamicFloat32_BoxedInt16(0));
+			deq(1, DynamicFloat32_BoxedInt16(1));
+			deq(0., DynamicFloat32_BoxedInt16(0.));
+			deq(1., DynamicFloat32_BoxedInt16(1.));
+			deq(0, Float32_BoxedInt32(0));
+			deq(1, Float32_BoxedInt32(1));
+			deq(0., Float32_BoxedInt32(0.));
+			deq(1., Float32_BoxedInt32(1.));
+			deq(0, DynamicFloat32_BoxedInt32(0));
+			deq(1, DynamicFloat32_BoxedInt32(1));
+			deq(0., DynamicFloat32_BoxedInt32(0.));
+			deq(1., DynamicFloat32_BoxedInt32(1.));
+			deq(0, Float32_BoxedInt64(0));
+			deq(1, Float32_BoxedInt64(1));
+			deq(0., Float32_BoxedInt64(0.));
+			deq(1., Float32_BoxedInt64(1.));
+			deq(0, DynamicFloat32_BoxedInt64(0));
+			deq(1, DynamicFloat32_BoxedInt64(1));
+			deq(0., DynamicFloat32_BoxedInt64(0.));
+			deq(1., DynamicFloat32_BoxedInt64(1.));
+			deq(0, Float32_BoxedFloat32(0));
+			deq(1, Float32_BoxedFloat32(1));
+			deq(0., Float32_BoxedFloat32(0.));
+			deq(1., Float32_BoxedFloat32(1.));
+			deq(0, DynamicFloat32_BoxedFloat32(0));
+			deq(1, DynamicFloat32_BoxedFloat32(1));
+			deq(0., DynamicFloat32_BoxedFloat32(0.));
+			deq(1., DynamicFloat32_BoxedFloat32(1.));
+			deq(0, Float32_BoxedFloat64(0));
+			deq(1, Float32_BoxedFloat64(1));
+			deq(0., Float32_BoxedFloat64(0.));
+			deq(1., Float32_BoxedFloat64(1.));
+			deq(0, DynamicFloat32_BoxedFloat64(0));
+			deq(1, DynamicFloat32_BoxedFloat64(1));
+			deq(0., DynamicFloat32_BoxedFloat64(0.));
+			deq(1., DynamicFloat32_BoxedFloat64(1.));
+			deq(0, Float64_Int8(0));
+			deq(1, Float64_Int8(1));
+			deq(0., Float64_Int8(0.));
+			deq(1., Float64_Int8(1.));
+			deq(0, DynamicFloat64_Int8(0));
+			deq(1, DynamicFloat64_Int8(1));
+			deq(0., DynamicFloat64_Int8(0.));
+			deq(1., DynamicFloat64_Int8(1.));
+			deq(0, Float64_Int16(0));
+			deq(1, Float64_Int16(1));
+			deq(0., Float64_Int16(0.));
+			deq(1., Float64_Int16(1.));
+			deq(0, DynamicFloat64_Int16(0));
+			deq(1, DynamicFloat64_Int16(1));
+			deq(0., DynamicFloat64_Int16(0.));
+			deq(1., DynamicFloat64_Int16(1.));
+			deq(0, Float64_Int32(0));
+			deq(1, Float64_Int32(1));
+			deq(0., Float64_Int32(0.));
+			deq(1., Float64_Int32(1.));
+			deq(0, DynamicFloat64_Int32(0));
+			deq(1, DynamicFloat64_Int32(1));
+			deq(0., DynamicFloat64_Int32(0.));
+			deq(1., DynamicFloat64_Int32(1.));
+			deq(0, Float64_Int64(0));
+			deq(1, Float64_Int64(1));
+			deq(0., Float64_Int64(0.));
+			deq(1., Float64_Int64(1.));
+			deq(0, DynamicFloat64_Int64(0));
+			deq(1, DynamicFloat64_Int64(1));
+			deq(0., DynamicFloat64_Int64(0.));
+			deq(1., DynamicFloat64_Int64(1.));
+			deq(0, Float64_Float32(0));
+			deq(1, Float64_Float32(1));
+			deq(0., Float64_Float32(0.));
+			deq(1., Float64_Float32(1.));
+			deq(0, DynamicFloat64_Float32(0));
+			deq(1, DynamicFloat64_Float32(1));
+			deq(0., DynamicFloat64_Float32(0.));
+			deq(1., DynamicFloat64_Float32(1.));
+			deq(0, Float64_BoxedInt8(0));
+			deq(1, Float64_BoxedInt8(1));
+			deq(0., Float64_BoxedInt8(0.));
+			deq(1., Float64_BoxedInt8(1.));
+			deq(0, DynamicFloat64_BoxedInt8(0));
+			deq(1, DynamicFloat64_BoxedInt8(1));
+			deq(0., DynamicFloat64_BoxedInt8(0.));
+			deq(1., DynamicFloat64_BoxedInt8(1.));
+			deq(0, Float64_BoxedInt16(0));
+			deq(1, Float64_BoxedInt16(1));
+			deq(0., Float64_BoxedInt16(0.));
+			deq(1., Float64_BoxedInt16(1.));
+			deq(0, DynamicFloat64_BoxedInt16(0));
+			deq(1, DynamicFloat64_BoxedInt16(1));
+			deq(0., DynamicFloat64_BoxedInt16(0.));
+			deq(1., DynamicFloat64_BoxedInt16(1.));
+			deq(0, Float64_BoxedInt32(0));
+			deq(1, Float64_BoxedInt32(1));
+			deq(0., Float64_BoxedInt32(0.));
+			deq(1., Float64_BoxedInt32(1.));
+			deq(0, DynamicFloat64_BoxedInt32(0));
+			deq(1, DynamicFloat64_BoxedInt32(1));
+			deq(0., DynamicFloat64_BoxedInt32(0.));
+			deq(1., DynamicFloat64_BoxedInt32(1.));
+			deq(0, Float64_BoxedInt64(0));
+			deq(1, Float64_BoxedInt64(1));
+			deq(0., Float64_BoxedInt64(0.));
+			deq(1., Float64_BoxedInt64(1.));
+			deq(0, DynamicFloat64_BoxedInt64(0));
+			deq(1, DynamicFloat64_BoxedInt64(1));
+			deq(0., DynamicFloat64_BoxedInt64(0.));
+			deq(1., DynamicFloat64_BoxedInt64(1.));
+			deq(0, Float64_BoxedFloat32(0));
+			deq(1, Float64_BoxedFloat32(1));
+			deq(0., Float64_BoxedFloat32(0.));
+			deq(1., Float64_BoxedFloat32(1.));
+			deq(0, DynamicFloat64_BoxedFloat32(0));
+			deq(1, DynamicFloat64_BoxedFloat32(1));
+			deq(0., DynamicFloat64_BoxedFloat32(0.));
+			deq(1., DynamicFloat64_BoxedFloat32(1.));
+			deq(0, Float64_BoxedFloat64(0));
+			deq(1, Float64_BoxedFloat64(1));
+			deq(0., Float64_BoxedFloat64(0.));
+			deq(1., Float64_BoxedFloat64(1.));
+			deq(0, DynamicFloat64_BoxedFloat64(0));
+			deq(1, DynamicFloat64_BoxedFloat64(1));
+			deq(0., DynamicFloat64_BoxedFloat64(0.));
+			deq(1., DynamicFloat64_BoxedFloat64(1.));
+			deq(0, BoxedInt8_Int8(0));
+			deq(1, BoxedInt8_Int8(1));
+			deq(CastHelper.nullOr0, BoxedInt8_Int8(null));
+			deq(0, DynamicBoxedInt8_Int8(0));
+			deq(1, DynamicBoxedInt8_Int8(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt8_Int8(null));
+			deq(0, BoxedInt8_Int16(0));
+			deq(1, BoxedInt8_Int16(1));
+			deq(CastHelper.nullOr0, BoxedInt8_Int16(null));
+			deq(0, DynamicBoxedInt8_Int16(0));
+			deq(1, DynamicBoxedInt8_Int16(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt8_Int16(null));
+			deq(0, BoxedInt8_Int32(0));
+			deq(1, BoxedInt8_Int32(1));
+			deq(CastHelper.nullOr0, BoxedInt8_Int32(null));
+			deq(0, DynamicBoxedInt8_Int32(0));
+			deq(1, DynamicBoxedInt8_Int32(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt8_Int32(null));
+			deq(0, BoxedInt8_Int64(0));
+			deq(1, BoxedInt8_Int64(1));
+			deq(CastHelper.nullOr0, BoxedInt8_Int64(null));
+			deq(0, DynamicBoxedInt8_Int64(0));
+			deq(1, DynamicBoxedInt8_Int64(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt8_Int64(null));
+			deq(0, BoxedInt8_Float32(0));
+			deq(1, BoxedInt8_Float32(1));
+			deq(CastHelper.nullOr0, BoxedInt8_Float32(null));
+			deq(0, DynamicBoxedInt8_Float32(0));
+			deq(1, DynamicBoxedInt8_Float32(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt8_Float32(null));
+			deq(0, BoxedInt8_Float64(0));
+			deq(1, BoxedInt8_Float64(1));
+			deq(CastHelper.nullOr0, BoxedInt8_Float64(null));
+			deq(0, DynamicBoxedInt8_Float64(0));
+			deq(1, DynamicBoxedInt8_Float64(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt8_Float64(null));
+			deq(0, BoxedInt8_BoxedInt16(0));
+			deq(1, BoxedInt8_BoxedInt16(1));
+			deq(null, BoxedInt8_BoxedInt16(null));
+			deq(0, DynamicBoxedInt8_BoxedInt16(0));
+			deq(1, DynamicBoxedInt8_BoxedInt16(1));
+			deq(null, DynamicBoxedInt8_BoxedInt16(null));
+			deq(0, BoxedInt8_BoxedInt32(0));
+			deq(1, BoxedInt8_BoxedInt32(1));
+			deq(null, BoxedInt8_BoxedInt32(null));
+			deq(0, DynamicBoxedInt8_BoxedInt32(0));
+			deq(1, DynamicBoxedInt8_BoxedInt32(1));
+			deq(null, DynamicBoxedInt8_BoxedInt32(null));
+			deq(0, BoxedInt8_BoxedInt64(0));
+			deq(1, BoxedInt8_BoxedInt64(1));
+			deq(null, BoxedInt8_BoxedInt64(null));
+			deq(0, DynamicBoxedInt8_BoxedInt64(0));
+			deq(1, DynamicBoxedInt8_BoxedInt64(1));
+			deq(null, DynamicBoxedInt8_BoxedInt64(null));
+			deq(0, BoxedInt8_BoxedFloat32(0));
+			deq(1, BoxedInt8_BoxedFloat32(1));
+			deq(null, BoxedInt8_BoxedFloat32(null));
+			deq(0, DynamicBoxedInt8_BoxedFloat32(0));
+			deq(1, DynamicBoxedInt8_BoxedFloat32(1));
+			deq(null, DynamicBoxedInt8_BoxedFloat32(null));
+			deq(0, BoxedInt8_BoxedFloat64(0));
+			deq(1, BoxedInt8_BoxedFloat64(1));
+			deq(null, BoxedInt8_BoxedFloat64(null));
+			deq(0, DynamicBoxedInt8_BoxedFloat64(0));
+			deq(1, DynamicBoxedInt8_BoxedFloat64(1));
+			deq(null, DynamicBoxedInt8_BoxedFloat64(null));
+			deq(0, BoxedInt16_Int8(0));
+			deq(1, BoxedInt16_Int8(1));
+			deq(CastHelper.nullOr0, BoxedInt16_Int8(null));
+			deq(0, DynamicBoxedInt16_Int8(0));
+			deq(1, DynamicBoxedInt16_Int8(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt16_Int8(null));
+			deq(0, BoxedInt16_Int16(0));
+			deq(1, BoxedInt16_Int16(1));
+			deq(CastHelper.nullOr0, BoxedInt16_Int16(null));
+			deq(0, DynamicBoxedInt16_Int16(0));
+			deq(1, DynamicBoxedInt16_Int16(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt16_Int16(null));
+			deq(0, BoxedInt16_Int32(0));
+			deq(1, BoxedInt16_Int32(1));
+			deq(CastHelper.nullOr0, BoxedInt16_Int32(null));
+			deq(0, DynamicBoxedInt16_Int32(0));
+			deq(1, DynamicBoxedInt16_Int32(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt16_Int32(null));
+			deq(0, BoxedInt16_Int64(0));
+			deq(1, BoxedInt16_Int64(1));
+			deq(CastHelper.nullOr0, BoxedInt16_Int64(null));
+			deq(0, DynamicBoxedInt16_Int64(0));
+			deq(1, DynamicBoxedInt16_Int64(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt16_Int64(null));
+			deq(0, BoxedInt16_Float32(0));
+			deq(1, BoxedInt16_Float32(1));
+			deq(CastHelper.nullOr0, BoxedInt16_Float32(null));
+			deq(0, DynamicBoxedInt16_Float32(0));
+			deq(1, DynamicBoxedInt16_Float32(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt16_Float32(null));
+			deq(0, BoxedInt16_Float64(0));
+			deq(1, BoxedInt16_Float64(1));
+			deq(CastHelper.nullOr0, BoxedInt16_Float64(null));
+			deq(0, DynamicBoxedInt16_Float64(0));
+			deq(1, DynamicBoxedInt16_Float64(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt16_Float64(null));
+			deq(0, BoxedInt16_BoxedInt8(0));
+			deq(1, BoxedInt16_BoxedInt8(1));
+			deq(null, BoxedInt16_BoxedInt8(null));
+			deq(0, DynamicBoxedInt16_BoxedInt8(0));
+			deq(1, DynamicBoxedInt16_BoxedInt8(1));
+			deq(null, DynamicBoxedInt16_BoxedInt8(null));
+			deq(0, BoxedInt16_BoxedInt32(0));
+			deq(1, BoxedInt16_BoxedInt32(1));
+			deq(null, BoxedInt16_BoxedInt32(null));
+			deq(0, DynamicBoxedInt16_BoxedInt32(0));
+			deq(1, DynamicBoxedInt16_BoxedInt32(1));
+			deq(null, DynamicBoxedInt16_BoxedInt32(null));
+			deq(0, BoxedInt16_BoxedInt64(0));
+			deq(1, BoxedInt16_BoxedInt64(1));
+			deq(null, BoxedInt16_BoxedInt64(null));
+			deq(0, DynamicBoxedInt16_BoxedInt64(0));
+			deq(1, DynamicBoxedInt16_BoxedInt64(1));
+			deq(null, DynamicBoxedInt16_BoxedInt64(null));
+			deq(0, BoxedInt16_BoxedFloat32(0));
+			deq(1, BoxedInt16_BoxedFloat32(1));
+			deq(null, BoxedInt16_BoxedFloat32(null));
+			deq(0, DynamicBoxedInt16_BoxedFloat32(0));
+			deq(1, DynamicBoxedInt16_BoxedFloat32(1));
+			deq(null, DynamicBoxedInt16_BoxedFloat32(null));
+			deq(0, BoxedInt16_BoxedFloat64(0));
+			deq(1, BoxedInt16_BoxedFloat64(1));
+			deq(null, BoxedInt16_BoxedFloat64(null));
+			deq(0, DynamicBoxedInt16_BoxedFloat64(0));
+			deq(1, DynamicBoxedInt16_BoxedFloat64(1));
+			deq(null, DynamicBoxedInt16_BoxedFloat64(null));
+			deq(0, BoxedInt32_Int8(0));
+			deq(1, BoxedInt32_Int8(1));
+			deq(CastHelper.nullOr0, BoxedInt32_Int8(null));
+			deq(0, DynamicBoxedInt32_Int8(0));
+			deq(1, DynamicBoxedInt32_Int8(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt32_Int8(null));
+			deq(0, BoxedInt32_Int16(0));
+			deq(1, BoxedInt32_Int16(1));
+			deq(CastHelper.nullOr0, BoxedInt32_Int16(null));
+			deq(0, DynamicBoxedInt32_Int16(0));
+			deq(1, DynamicBoxedInt32_Int16(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt32_Int16(null));
+			deq(0, BoxedInt32_Int32(0));
+			deq(1, BoxedInt32_Int32(1));
+			deq(CastHelper.nullOr0, BoxedInt32_Int32(null));
+			deq(0, DynamicBoxedInt32_Int32(0));
+			deq(1, DynamicBoxedInt32_Int32(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt32_Int32(null));
+			deq(0, BoxedInt32_Int64(0));
+			deq(1, BoxedInt32_Int64(1));
+			deq(CastHelper.nullOr0, BoxedInt32_Int64(null));
+			deq(0, DynamicBoxedInt32_Int64(0));
+			deq(1, DynamicBoxedInt32_Int64(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt32_Int64(null));
+			deq(0, BoxedInt32_Float32(0));
+			deq(1, BoxedInt32_Float32(1));
+			deq(CastHelper.nullOr0, BoxedInt32_Float32(null));
+			deq(0, DynamicBoxedInt32_Float32(0));
+			deq(1, DynamicBoxedInt32_Float32(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt32_Float32(null));
+			deq(0, BoxedInt32_Float64(0));
+			deq(1, BoxedInt32_Float64(1));
+			deq(CastHelper.nullOr0, BoxedInt32_Float64(null));
+			deq(0, DynamicBoxedInt32_Float64(0));
+			deq(1, DynamicBoxedInt32_Float64(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt32_Float64(null));
+			deq(0, BoxedInt32_BoxedInt8(0));
+			deq(1, BoxedInt32_BoxedInt8(1));
+			deq(null, BoxedInt32_BoxedInt8(null));
+			deq(0, DynamicBoxedInt32_BoxedInt8(0));
+			deq(1, DynamicBoxedInt32_BoxedInt8(1));
+			deq(null, DynamicBoxedInt32_BoxedInt8(null));
+			deq(0, BoxedInt32_BoxedInt16(0));
+			deq(1, BoxedInt32_BoxedInt16(1));
+			deq(null, BoxedInt32_BoxedInt16(null));
+			deq(0, DynamicBoxedInt32_BoxedInt16(0));
+			deq(1, DynamicBoxedInt32_BoxedInt16(1));
+			deq(null, DynamicBoxedInt32_BoxedInt16(null));
+			deq(0, BoxedInt32_BoxedInt64(0));
+			deq(1, BoxedInt32_BoxedInt64(1));
+			deq(null, BoxedInt32_BoxedInt64(null));
+			deq(0, DynamicBoxedInt32_BoxedInt64(0));
+			deq(1, DynamicBoxedInt32_BoxedInt64(1));
+			deq(null, DynamicBoxedInt32_BoxedInt64(null));
+			deq(0, BoxedInt32_BoxedFloat32(0));
+			deq(1, BoxedInt32_BoxedFloat32(1));
+			deq(null, BoxedInt32_BoxedFloat32(null));
+			deq(0, DynamicBoxedInt32_BoxedFloat32(0));
+			deq(1, DynamicBoxedInt32_BoxedFloat32(1));
+			deq(null, DynamicBoxedInt32_BoxedFloat32(null));
+			deq(0, BoxedInt32_BoxedFloat64(0));
+			deq(1, BoxedInt32_BoxedFloat64(1));
+			deq(null, BoxedInt32_BoxedFloat64(null));
+			deq(0, DynamicBoxedInt32_BoxedFloat64(0));
+			deq(1, DynamicBoxedInt32_BoxedFloat64(1));
+			deq(null, DynamicBoxedInt32_BoxedFloat64(null));
+			deq(0, BoxedInt64_Int8(0));
+			deq(1, BoxedInt64_Int8(1));
+			deq(CastHelper.nullOr0, BoxedInt64_Int8(null));
+			deq(0, DynamicBoxedInt64_Int8(0));
+			deq(1, DynamicBoxedInt64_Int8(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt64_Int8(null));
+			deq(0, BoxedInt64_Int16(0));
+			deq(1, BoxedInt64_Int16(1));
+			deq(CastHelper.nullOr0, BoxedInt64_Int16(null));
+			deq(0, DynamicBoxedInt64_Int16(0));
+			deq(1, DynamicBoxedInt64_Int16(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt64_Int16(null));
+			deq(0, BoxedInt64_Int32(0));
+			deq(1, BoxedInt64_Int32(1));
+			deq(CastHelper.nullOr0, BoxedInt64_Int32(null));
+			deq(0, DynamicBoxedInt64_Int32(0));
+			deq(1, DynamicBoxedInt64_Int32(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt64_Int32(null));
+			deq(0, BoxedInt64_Int64(0));
+			deq(1, BoxedInt64_Int64(1));
+			deq(CastHelper.nullOr0, BoxedInt64_Int64(null));
+			deq(0, DynamicBoxedInt64_Int64(0));
+			deq(1, DynamicBoxedInt64_Int64(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt64_Int64(null));
+			deq(0, BoxedInt64_Float32(0));
+			deq(1, BoxedInt64_Float32(1));
+			deq(CastHelper.nullOr0, BoxedInt64_Float32(null));
+			deq(0, DynamicBoxedInt64_Float32(0));
+			deq(1, DynamicBoxedInt64_Float32(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt64_Float32(null));
+			deq(0, BoxedInt64_Float64(0));
+			deq(1, BoxedInt64_Float64(1));
+			deq(CastHelper.nullOr0, BoxedInt64_Float64(null));
+			deq(0, DynamicBoxedInt64_Float64(0));
+			deq(1, DynamicBoxedInt64_Float64(1));
+			deq(CastHelper.nullOr0, DynamicBoxedInt64_Float64(null));
+			deq(0, BoxedInt64_BoxedInt8(0));
+			deq(1, BoxedInt64_BoxedInt8(1));
+			deq(null, BoxedInt64_BoxedInt8(null));
+			deq(0, DynamicBoxedInt64_BoxedInt8(0));
+			deq(1, DynamicBoxedInt64_BoxedInt8(1));
+			deq(null, DynamicBoxedInt64_BoxedInt8(null));
+			deq(0, BoxedInt64_BoxedInt16(0));
+			deq(1, BoxedInt64_BoxedInt16(1));
+			deq(null, BoxedInt64_BoxedInt16(null));
+			deq(0, DynamicBoxedInt64_BoxedInt16(0));
+			deq(1, DynamicBoxedInt64_BoxedInt16(1));
+			deq(null, DynamicBoxedInt64_BoxedInt16(null));
+			deq(0, BoxedInt64_BoxedInt32(0));
+			deq(1, BoxedInt64_BoxedInt32(1));
+			deq(null, BoxedInt64_BoxedInt32(null));
+			deq(0, DynamicBoxedInt64_BoxedInt32(0));
+			deq(1, DynamicBoxedInt64_BoxedInt32(1));
+			deq(null, DynamicBoxedInt64_BoxedInt32(null));
+			deq(0, BoxedInt64_BoxedFloat32(0));
+			deq(1, BoxedInt64_BoxedFloat32(1));
+			deq(null, BoxedInt64_BoxedFloat32(null));
+			deq(0, DynamicBoxedInt64_BoxedFloat32(0));
+			deq(1, DynamicBoxedInt64_BoxedFloat32(1));
+			deq(null, DynamicBoxedInt64_BoxedFloat32(null));
+			deq(0, BoxedInt64_BoxedFloat64(0));
+			deq(1, BoxedInt64_BoxedFloat64(1));
+			deq(null, BoxedInt64_BoxedFloat64(null));
+			deq(0, DynamicBoxedInt64_BoxedFloat64(0));
+			deq(1, DynamicBoxedInt64_BoxedFloat64(1));
+			deq(null, DynamicBoxedInt64_BoxedFloat64(null));
+			deq(0, BoxedFloat32_Int8(0));
+			deq(1, BoxedFloat32_Int8(1));
+			deq(0., BoxedFloat32_Int8(0.));
+			deq(1., BoxedFloat32_Int8(1.));
+			deq(CastHelper.nullOr0, BoxedFloat32_Int8(null));
+			deq(0, DynamicBoxedFloat32_Int8(0));
+			deq(1, DynamicBoxedFloat32_Int8(1));
+			deq(0., DynamicBoxedFloat32_Int8(0.));
+			deq(1., DynamicBoxedFloat32_Int8(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat32_Int8(null));
+			deq(0, BoxedFloat32_Int16(0));
+			deq(1, BoxedFloat32_Int16(1));
+			deq(0., BoxedFloat32_Int16(0.));
+			deq(1., BoxedFloat32_Int16(1.));
+			deq(CastHelper.nullOr0, BoxedFloat32_Int16(null));
+			deq(0, DynamicBoxedFloat32_Int16(0));
+			deq(1, DynamicBoxedFloat32_Int16(1));
+			deq(0., DynamicBoxedFloat32_Int16(0.));
+			deq(1., DynamicBoxedFloat32_Int16(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat32_Int16(null));
+			deq(0, BoxedFloat32_Int32(0));
+			deq(1, BoxedFloat32_Int32(1));
+			deq(0., BoxedFloat32_Int32(0.));
+			deq(1., BoxedFloat32_Int32(1.));
+			deq(CastHelper.nullOr0, BoxedFloat32_Int32(null));
+			deq(0, DynamicBoxedFloat32_Int32(0));
+			deq(1, DynamicBoxedFloat32_Int32(1));
+			deq(0., DynamicBoxedFloat32_Int32(0.));
+			deq(1., DynamicBoxedFloat32_Int32(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat32_Int32(null));
+			deq(0, BoxedFloat32_Int64(0));
+			deq(1, BoxedFloat32_Int64(1));
+			deq(0., BoxedFloat32_Int64(0.));
+			deq(1., BoxedFloat32_Int64(1.));
+			deq(CastHelper.nullOr0, BoxedFloat32_Int64(null));
+			deq(0, DynamicBoxedFloat32_Int64(0));
+			deq(1, DynamicBoxedFloat32_Int64(1));
+			deq(0., DynamicBoxedFloat32_Int64(0.));
+			deq(1., DynamicBoxedFloat32_Int64(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat32_Int64(null));
+			deq(0, BoxedFloat32_Float32(0));
+			deq(1, BoxedFloat32_Float32(1));
+			deq(0., BoxedFloat32_Float32(0.));
+			deq(1., BoxedFloat32_Float32(1.));
+			deq(CastHelper.nullOr0, BoxedFloat32_Float32(null));
+			deq(0, DynamicBoxedFloat32_Float32(0));
+			deq(1, DynamicBoxedFloat32_Float32(1));
+			deq(0., DynamicBoxedFloat32_Float32(0.));
+			deq(1., DynamicBoxedFloat32_Float32(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat32_Float32(null));
+			deq(0, BoxedFloat32_Float64(0));
+			deq(1, BoxedFloat32_Float64(1));
+			deq(0., BoxedFloat32_Float64(0.));
+			deq(1., BoxedFloat32_Float64(1.));
+			deq(CastHelper.nullOr0, BoxedFloat32_Float64(null));
+			deq(0, DynamicBoxedFloat32_Float64(0));
+			deq(1, DynamicBoxedFloat32_Float64(1));
+			deq(0., DynamicBoxedFloat32_Float64(0.));
+			deq(1., DynamicBoxedFloat32_Float64(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat32_Float64(null));
+			deq(0, BoxedFloat32_BoxedInt8(0));
+			deq(1, BoxedFloat32_BoxedInt8(1));
+			deq(0., BoxedFloat32_BoxedInt8(0.));
+			deq(1., BoxedFloat32_BoxedInt8(1.));
+			deq(null, BoxedFloat32_BoxedInt8(null));
+			deq(0, DynamicBoxedFloat32_BoxedInt8(0));
+			deq(1, DynamicBoxedFloat32_BoxedInt8(1));
+			deq(0., DynamicBoxedFloat32_BoxedInt8(0.));
+			deq(1., DynamicBoxedFloat32_BoxedInt8(1.));
+			deq(null, DynamicBoxedFloat32_BoxedInt8(null));
+			deq(0, BoxedFloat32_BoxedInt16(0));
+			deq(1, BoxedFloat32_BoxedInt16(1));
+			deq(0., BoxedFloat32_BoxedInt16(0.));
+			deq(1., BoxedFloat32_BoxedInt16(1.));
+			deq(null, BoxedFloat32_BoxedInt16(null));
+			deq(0, DynamicBoxedFloat32_BoxedInt16(0));
+			deq(1, DynamicBoxedFloat32_BoxedInt16(1));
+			deq(0., DynamicBoxedFloat32_BoxedInt16(0.));
+			deq(1., DynamicBoxedFloat32_BoxedInt16(1.));
+			deq(null, DynamicBoxedFloat32_BoxedInt16(null));
+			deq(0, BoxedFloat32_BoxedInt32(0));
+			deq(1, BoxedFloat32_BoxedInt32(1));
+			deq(0., BoxedFloat32_BoxedInt32(0.));
+			deq(1., BoxedFloat32_BoxedInt32(1.));
+			deq(null, BoxedFloat32_BoxedInt32(null));
+			deq(0, DynamicBoxedFloat32_BoxedInt32(0));
+			deq(1, DynamicBoxedFloat32_BoxedInt32(1));
+			deq(0., DynamicBoxedFloat32_BoxedInt32(0.));
+			deq(1., DynamicBoxedFloat32_BoxedInt32(1.));
+			deq(null, DynamicBoxedFloat32_BoxedInt32(null));
+			deq(0, BoxedFloat32_BoxedInt64(0));
+			deq(1, BoxedFloat32_BoxedInt64(1));
+			deq(0., BoxedFloat32_BoxedInt64(0.));
+			deq(1., BoxedFloat32_BoxedInt64(1.));
+			deq(null, BoxedFloat32_BoxedInt64(null));
+			deq(0, DynamicBoxedFloat32_BoxedInt64(0));
+			deq(1, DynamicBoxedFloat32_BoxedInt64(1));
+			deq(0., DynamicBoxedFloat32_BoxedInt64(0.));
+			deq(1., DynamicBoxedFloat32_BoxedInt64(1.));
+			deq(null, DynamicBoxedFloat32_BoxedInt64(null));
+			deq(0, BoxedFloat32_BoxedFloat64(0));
+			deq(1, BoxedFloat32_BoxedFloat64(1));
+			deq(0., BoxedFloat32_BoxedFloat64(0.));
+			deq(1., BoxedFloat32_BoxedFloat64(1.));
+			deq(null, BoxedFloat32_BoxedFloat64(null));
+			deq(0, DynamicBoxedFloat32_BoxedFloat64(0));
+			deq(1, DynamicBoxedFloat32_BoxedFloat64(1));
+			deq(0., DynamicBoxedFloat32_BoxedFloat64(0.));
+			deq(1., DynamicBoxedFloat32_BoxedFloat64(1.));
+			deq(null, DynamicBoxedFloat32_BoxedFloat64(null));
+			deq(0, BoxedFloat64_Int8(0));
+			deq(1, BoxedFloat64_Int8(1));
+			deq(0., BoxedFloat64_Int8(0.));
+			deq(1., BoxedFloat64_Int8(1.));
+			deq(CastHelper.nullOr0, BoxedFloat64_Int8(null));
+			deq(0, DynamicBoxedFloat64_Int8(0));
+			deq(1, DynamicBoxedFloat64_Int8(1));
+			deq(0., DynamicBoxedFloat64_Int8(0.));
+			deq(1., DynamicBoxedFloat64_Int8(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat64_Int8(null));
+			deq(0, BoxedFloat64_Int16(0));
+			deq(1, BoxedFloat64_Int16(1));
+			deq(0., BoxedFloat64_Int16(0.));
+			deq(1., BoxedFloat64_Int16(1.));
+			deq(CastHelper.nullOr0, BoxedFloat64_Int16(null));
+			deq(0, DynamicBoxedFloat64_Int16(0));
+			deq(1, DynamicBoxedFloat64_Int16(1));
+			deq(0., DynamicBoxedFloat64_Int16(0.));
+			deq(1., DynamicBoxedFloat64_Int16(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat64_Int16(null));
+			deq(0, BoxedFloat64_Int32(0));
+			deq(1, BoxedFloat64_Int32(1));
+			deq(0., BoxedFloat64_Int32(0.));
+			deq(1., BoxedFloat64_Int32(1.));
+			deq(CastHelper.nullOr0, BoxedFloat64_Int32(null));
+			deq(0, DynamicBoxedFloat64_Int32(0));
+			deq(1, DynamicBoxedFloat64_Int32(1));
+			deq(0., DynamicBoxedFloat64_Int32(0.));
+			deq(1., DynamicBoxedFloat64_Int32(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat64_Int32(null));
+			deq(0, BoxedFloat64_Int64(0));
+			deq(1, BoxedFloat64_Int64(1));
+			deq(0., BoxedFloat64_Int64(0.));
+			deq(1., BoxedFloat64_Int64(1.));
+			deq(CastHelper.nullOr0, BoxedFloat64_Int64(null));
+			deq(0, DynamicBoxedFloat64_Int64(0));
+			deq(1, DynamicBoxedFloat64_Int64(1));
+			deq(0., DynamicBoxedFloat64_Int64(0.));
+			deq(1., DynamicBoxedFloat64_Int64(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat64_Int64(null));
+			deq(0, BoxedFloat64_Float32(0));
+			deq(1, BoxedFloat64_Float32(1));
+			deq(0., BoxedFloat64_Float32(0.));
+			deq(1., BoxedFloat64_Float32(1.));
+			deq(CastHelper.nullOr0, BoxedFloat64_Float32(null));
+			deq(0, DynamicBoxedFloat64_Float32(0));
+			deq(1, DynamicBoxedFloat64_Float32(1));
+			deq(0., DynamicBoxedFloat64_Float32(0.));
+			deq(1., DynamicBoxedFloat64_Float32(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat64_Float32(null));
+			deq(0, BoxedFloat64_Float64(0));
+			deq(1, BoxedFloat64_Float64(1));
+			deq(0., BoxedFloat64_Float64(0.));
+			deq(1., BoxedFloat64_Float64(1.));
+			deq(CastHelper.nullOr0, BoxedFloat64_Float64(null));
+			deq(0, DynamicBoxedFloat64_Float64(0));
+			deq(1, DynamicBoxedFloat64_Float64(1));
+			deq(0., DynamicBoxedFloat64_Float64(0.));
+			deq(1., DynamicBoxedFloat64_Float64(1.));
+			deq(CastHelper.nullOr0, DynamicBoxedFloat64_Float64(null));
+			deq(0, BoxedFloat64_BoxedInt8(0));
+			deq(1, BoxedFloat64_BoxedInt8(1));
+			deq(0., BoxedFloat64_BoxedInt8(0.));
+			deq(1., BoxedFloat64_BoxedInt8(1.));
+			deq(null, BoxedFloat64_BoxedInt8(null));
+			deq(0, DynamicBoxedFloat64_BoxedInt8(0));
+			deq(1, DynamicBoxedFloat64_BoxedInt8(1));
+			deq(0., DynamicBoxedFloat64_BoxedInt8(0.));
+			deq(1., DynamicBoxedFloat64_BoxedInt8(1.));
+			deq(null, DynamicBoxedFloat64_BoxedInt8(null));
+			deq(0, BoxedFloat64_BoxedInt16(0));
+			deq(1, BoxedFloat64_BoxedInt16(1));
+			deq(0., BoxedFloat64_BoxedInt16(0.));
+			deq(1., BoxedFloat64_BoxedInt16(1.));
+			deq(null, BoxedFloat64_BoxedInt16(null));
+			deq(0, DynamicBoxedFloat64_BoxedInt16(0));
+			deq(1, DynamicBoxedFloat64_BoxedInt16(1));
+			deq(0., DynamicBoxedFloat64_BoxedInt16(0.));
+			deq(1., DynamicBoxedFloat64_BoxedInt16(1.));
+			deq(null, DynamicBoxedFloat64_BoxedInt16(null));
+			deq(0, BoxedFloat64_BoxedInt32(0));
+			deq(1, BoxedFloat64_BoxedInt32(1));
+			deq(0., BoxedFloat64_BoxedInt32(0.));
+			deq(1., BoxedFloat64_BoxedInt32(1.));
+			deq(null, BoxedFloat64_BoxedInt32(null));
+			deq(0, DynamicBoxedFloat64_BoxedInt32(0));
+			deq(1, DynamicBoxedFloat64_BoxedInt32(1));
+			deq(0., DynamicBoxedFloat64_BoxedInt32(0.));
+			deq(1., DynamicBoxedFloat64_BoxedInt32(1.));
+			deq(null, DynamicBoxedFloat64_BoxedInt32(null));
+			deq(0, BoxedFloat64_BoxedInt64(0));
+			deq(1, BoxedFloat64_BoxedInt64(1));
+			deq(0., BoxedFloat64_BoxedInt64(0.));
+			deq(1., BoxedFloat64_BoxedInt64(1.));
+			deq(null, BoxedFloat64_BoxedInt64(null));
+			deq(0, DynamicBoxedFloat64_BoxedInt64(0));
+			deq(1, DynamicBoxedFloat64_BoxedInt64(1));
+			deq(0., DynamicBoxedFloat64_BoxedInt64(0.));
+			deq(1., DynamicBoxedFloat64_BoxedInt64(1.));
+			deq(null, DynamicBoxedFloat64_BoxedInt64(null));
+			deq(0, BoxedFloat64_BoxedFloat32(0));
+			deq(1, BoxedFloat64_BoxedFloat32(1));
+			deq(0., BoxedFloat64_BoxedFloat32(0.));
+			deq(1., BoxedFloat64_BoxedFloat32(1.));
+			deq(null, BoxedFloat64_BoxedFloat32(null));
+			deq(0, DynamicBoxedFloat64_BoxedFloat32(0));
+			deq(1, DynamicBoxedFloat64_BoxedFloat32(1));
+			deq(0., DynamicBoxedFloat64_BoxedFloat32(0.));
+			deq(1., DynamicBoxedFloat64_BoxedFloat32(1.));
+			deq(null, DynamicBoxedFloat64_BoxedFloat32(null));
+		};
+	}
+	function deq(expected:Dynamic, actual:Dynamic, ?p:haxe.PosInfos) {
+		eq(expected, actual, p);
+	}
+}