diff --git a/projects/xUnit/objects/objRunner/Create_0.gml b/projects/xUnit/objects/objRunner/Create_0.gml
index 80050dfe..49d7b9f7 100644
--- a/projects/xUnit/objects/objRunner/Create_0.gml
+++ b/projects/xUnit/objects/objRunner/Create_0.gml
@@ -47,6 +47,7 @@ testFramework.addSuite(BasicTilemapTestSuite);
 testFramework.addSuite(BasicUnaryUpdateExpressions);
 testFramework.addSuite(BasicVariableTestSuite);
 testFramework.addSuite(BasicWeakRefsTestSuite);
+testFramework.addSuite(BasicCompileEvalConsistencyTestSuite);
 testFramework.addSuite(ResourceAudioBuffersTestSuite);
 testFramework.addSuite(ResourceAudioEffectsTestSuite);
 testFramework.addSuite(ResourceAudioEmittersTestSuite);
diff --git a/projects/xUnit/rooms/rmInit/rmInit.yy b/projects/xUnit/rooms/rmInit/rmInit.yy
index 13266a6c..f529ac35 100644
--- a/projects/xUnit/rooms/rmInit/rmInit.yy
+++ b/projects/xUnit/rooms/rmInit/rmInit.yy
@@ -11,7 +11,7 @@
   "isDnd":false,
   "layers":[
     {"$GMRInstanceLayer":"","%Name":"Instances","depth":0,"effectEnabled":true,"effectType":null,"gridX":32,"gridY":32,"hierarchyFrozen":false,"inheritLayerDepth":false,"inheritLayerSettings":false,"inheritSubLayers":true,"inheritVisibility":true,"instances":[
-        {"$GMRInstance":"v1","%Name":"inst_17629EC3","colour":4294967295,"frozen":false,"hasCreationCode":false,"ignore":false,"imageIndex":0,"imageSpeed":1.0,"inheritCode":false,"inheritedItemId":null,"inheritItemSettings":false,"isDnd":false,"name":"inst_17629EC3","objectId":{"name":"objRunner","path":"objects/objRunner/objRunner.yy",},"properties":[],"resourceType":"GMRInstance","resourceVersion":"2.0","rotation":0.0,"scaleX":1.0,"scaleY":1.0,"x":32.0,"y":32.0,},
+        {"$GMRInstance":"v2","%Name":"inst_17629EC3","colour":4294967295,"frozen":false,"hasCreationCode":false,"ignore":false,"imageIndex":0,"imageSpeed":1.0,"inheritCode":false,"inheritedItemId":null,"inheritItemSettings":false,"isDnd":false,"name":"inst_17629EC3","objectId":{"name":"objRunner","path":"objects/objRunner/objRunner.yy",},"properties":[],"resourceType":"GMRInstance","resourceVersion":"2.0","rotation":0.0,"scaleX":1.0,"scaleY":1.0,"x":32.0,"y":32.0,},
       ],"layers":[],"name":"Instances","properties":[],"resourceType":"GMRInstanceLayer","resourceVersion":"2.0","userdefinedDepth":false,"visible":true,},
     {"$GMRBackgroundLayer":"","%Name":"Background","animationFPS":15.0,"animationSpeedType":0,"colour":4278190080,"depth":100,"effectEnabled":true,"effectType":null,"gridX":32,"gridY":32,"hierarchyFrozen":false,"hspeed":0.0,"htiled":false,"inheritLayerDepth":false,"inheritLayerSettings":false,"inheritSubLayers":true,"inheritVisibility":true,"layers":[],"name":"Background","properties":[],"resourceType":"GMRBackgroundLayer","resourceVersion":"2.0","spriteId":null,"stretch":false,"userdefinedAnimFPS":false,"userdefinedDepth":false,"visible":true,"vspeed":0.0,"vtiled":false,"x":0,"y":0,},
   ],
diff --git a/projects/xUnit/rooms/room0/room0.yy b/projects/xUnit/rooms/room0/room0.yy
index e0beb24e..804871d3 100644
--- a/projects/xUnit/rooms/room0/room0.yy
+++ b/projects/xUnit/rooms/room0/room0.yy
@@ -9,7 +9,7 @@
   "isDnd":false,
   "layers":[
     {"$GMRAssetLayer":"","%Name":"Assets","assets":[
-        {"$GMRSpriteGraphic":"","%Name":"graphic_7C377683","animationSpeed":1.0,"colour":4294967295,"frozen":false,"headPosition":0.0,"ignore":false,"inheritedItemId":null,"inheritItemSettings":false,"name":"graphic_7C377683","resourceType":"GMRSpriteGraphic","resourceVersion":"2.0","rotation":0.0,"scaleX":1.0,"scaleY":1.0,"spriteId":{"name":"sprSquare","path":"sprites/sprSquare/sprSquare.yy",},"x":960.0,"y":64.0,},
+        {"$GMRSpriteGraphic":"v1","%Name":"graphic_7C377683","animationSpeed":1.0,"colour":4294967295,"frozen":false,"headPosition":0.0,"ignore":false,"inheritedItemId":null,"inheritItemSettings":false,"name":"graphic_7C377683","resourceType":"GMRSpriteGraphic","resourceVersion":"2.0","rotation":0.0,"scaleX":1.0,"scaleY":1.0,"spriteId":{"name":"sprSquare","path":"sprites/sprSquare/sprSquare.yy",},"x":960.0,"y":64.0,},
       ],"depth":0,"effectEnabled":true,"effectType":null,"gridX":32,"gridY":32,"hierarchyFrozen":false,"inheritLayerDepth":false,"inheritLayerSettings":false,"inheritSubLayers":true,"inheritVisibility":true,"layers":[],"name":"Assets","properties":[],"resourceType":"GMRAssetLayer","resourceVersion":"2.0","userdefinedDepth":false,"visible":true,},
     {"$GMRTileLayer":"","%Name":"Tiles","depth":100,"effectEnabled":true,"effectType":null,"gridX":32,"gridY":32,"hierarchyFrozen":false,"inheritLayerDepth":false,"inheritLayerSettings":false,"inheritSubLayers":true,"inheritVisibility":true,"layers":[],"name":"Tiles","properties":[],"resourceType":"GMRTileLayer","resourceVersion":"2.0","tiles":{"SerialiseHeight":77,"SerialiseWidth":103,"TileCompressedData":[-7931,0,],"TileDataFormat":1,},"tilesetId":{"name":"tilesAuto","path":"tilesets/tilesAuto/tilesAuto.yy",},"userdefinedDepth":false,"visible":true,"x":0,"y":0,},
     {"$GMRInstanceLayer":"","%Name":"Instances","depth":200,"effectEnabled":true,"effectType":null,"gridX":32,"gridY":32,"hierarchyFrozen":false,"inheritLayerDepth":false,"inheritLayerSettings":false,"inheritSubLayers":true,"inheritVisibility":true,"instances":[],"layers":[],"name":"Instances","properties":[],"resourceType":"GMRInstanceLayer","resourceVersion":"2.0","userdefinedDepth":false,"visible":true,},
diff --git a/projects/xUnit/scripts/BasicCompileEvalConsistencyTestSuite/BasicCompileEvalConsistencyTestSuite.gml b/projects/xUnit/scripts/BasicCompileEvalConsistencyTestSuite/BasicCompileEvalConsistencyTestSuite.gml
new file mode 100644
index 00000000..18409ea1
--- /dev/null
+++ b/projects/xUnit/scripts/BasicCompileEvalConsistencyTestSuite/BasicCompileEvalConsistencyTestSuite.gml
@@ -0,0 +1,3887 @@
+function BasicCompileEvalConsistencyTestSuite() : TestSuite() constructor {
+
+#region === Binary Operators ===
+
+    addFact("& - 0b & 0b", function() {
+        var result_ct = 0b1011 & 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "0b & 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b & 0b :: type mismatch");
+    });
+
+    addFact("& - 0b & 0x", function() {
+        var result_ct = 0b1011 & 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "0b & 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b & 0x :: type mismatch");
+    });
+
+    addFact("& - 0b & Unsigned-real", function() {
+        var result_ct = 0b1011 & 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "0b & Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b & Unsigned-real :: type mismatch");
+    });
+
+    addFact("& - 0b & Signed-real", function() {
+        var result_ct = 0b1011 & 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "0b & Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b & Signed-real :: type mismatch");
+    });
+
+    addFact("& - 0x & 0b", function() {
+        var result_ct = 0xA7 & 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "0x & 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x & 0b :: type mismatch");
+    });
+
+    addFact("& - 0x & 0x", function() {
+        var result_ct = 0xA7 & 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "0x & 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x & 0x :: type mismatch");
+    });
+
+    addFact("& - 0x & Unsigned-real", function() {
+        var result_ct = 0xA7 & 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "0x & Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x & Unsigned-real :: type mismatch");
+    });
+
+    addFact("& - 0x & Signed-real", function() {
+        var result_ct = 0xA7 & 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "0x & Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x & Signed-real :: type mismatch");
+    });
+
+    addFact("& - Unsigned-real & 0b", function() {
+        var result_ct = 167 & 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real & 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real & 0b :: type mismatch");
+    });
+
+    addFact("& - Unsigned-real & 0x", function() {
+        var result_ct = 167 & 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real & 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real & 0x :: type mismatch");
+    });
+
+    addFact("& - Unsigned-real & Unsigned-real", function() {
+        var result_ct = 167 & 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real & Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real & Unsigned-real :: type mismatch");
+    });
+
+    addFact("& - Unsigned-real & Signed-real", function() {
+        var result_ct = 167 & 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real & Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real & Signed-real :: type mismatch");
+    });
+
+    addFact("& - Signed-real & 0b", function() {
+        var result_ct = 1.5 & 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real & 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real & 0b :: type mismatch");
+    });
+
+    addFact("& - Signed-real & 0x", function() {
+        var result_ct = 1.5 & 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real & 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real & 0x :: type mismatch");
+    });
+
+    addFact("& - Signed-real & Unsigned-real", function() {
+        var result_ct = 1.5 & 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real & Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real & Unsigned-real :: type mismatch");
+    });
+
+    addFact("& - Signed-real & Signed-real", function() {
+        var result_ct = 1.5 & 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a & b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real & Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real & Signed-real :: type mismatch");
+    });
+
+    addFact("| - 0b | 0b", function() {
+        var result_ct = 0b1011 | 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "0b | 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b | 0b :: type mismatch");
+    });
+
+    addFact("| - 0b | 0x", function() {
+        var result_ct = 0b1011 | 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "0b | 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b | 0x :: type mismatch");
+    });
+
+    addFact("| - 0b | Unsigned-real", function() {
+        var result_ct = 0b1011 | 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "0b | Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b | Unsigned-real :: type mismatch");
+    });
+
+    addFact("| - 0b | Signed-real", function() {
+        var result_ct = 0b1011 | 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "0b | Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b | Signed-real :: type mismatch");
+    });
+
+    addFact("| - 0x | 0b", function() {
+        var result_ct = 0xA7 | 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "0x | 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x | 0b :: type mismatch");
+    });
+
+    addFact("| - 0x | 0x", function() {
+        var result_ct = 0xA7 | 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "0x | 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x | 0x :: type mismatch");
+    });
+
+    addFact("| - 0x | Unsigned-real", function() {
+        var result_ct = 0xA7 | 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "0x | Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x | Unsigned-real :: type mismatch");
+    });
+
+    addFact("| - 0x | Signed-real", function() {
+        var result_ct = 0xA7 | 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "0x | Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x | Signed-real :: type mismatch");
+    });
+
+    addFact("| - Unsigned-real | 0b", function() {
+        var result_ct = 167 | 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real | 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real | 0b :: type mismatch");
+    });
+
+    addFact("| - Unsigned-real | 0x", function() {
+        var result_ct = 167 | 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real | 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real | 0x :: type mismatch");
+    });
+
+    addFact("| - Unsigned-real | Unsigned-real", function() {
+        var result_ct = 167 | 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real | Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real | Unsigned-real :: type mismatch");
+    });
+
+    addFact("| - Unsigned-real | Signed-real", function() {
+        var result_ct = 167 | 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real | Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real | Signed-real :: type mismatch");
+    });
+
+    addFact("| - Signed-real | 0b", function() {
+        var result_ct = 1.5 | 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real | 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real | 0b :: type mismatch");
+    });
+
+    addFact("| - Signed-real | 0x", function() {
+        var result_ct = 1.5 | 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real | 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real | 0x :: type mismatch");
+    });
+
+    addFact("| - Signed-real | Unsigned-real", function() {
+        var result_ct = 1.5 | 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real | Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real | Unsigned-real :: type mismatch");
+    });
+
+    addFact("| - Signed-real | Signed-real", function() {
+        var result_ct = 1.5 | 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a | b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real | Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real | Signed-real :: type mismatch");
+    });
+
+    addFact("^ - 0b ^ 0b", function() {
+        var result_ct = 0b1011 ^ 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "0b ^ 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ^ 0b :: type mismatch");
+    });
+
+    addFact("^ - 0b ^ 0x", function() {
+        var result_ct = 0b1011 ^ 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "0b ^ 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ^ 0x :: type mismatch");
+    });
+
+    addFact("^ - 0b ^ Unsigned-real", function() {
+        var result_ct = 0b1011 ^ 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "0b ^ Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ^ Unsigned-real :: type mismatch");
+    });
+
+    addFact("^ - 0b ^ Signed-real", function() {
+        var result_ct = 0b1011 ^ 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "0b ^ Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ^ Signed-real :: type mismatch");
+    });
+
+    addFact("^ - 0x ^ 0b", function() {
+        var result_ct = 0xA7 ^ 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "0x ^ 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ^ 0b :: type mismatch");
+    });
+
+    addFact("^ - 0x ^ 0x", function() {
+        var result_ct = 0xA7 ^ 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "0x ^ 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ^ 0x :: type mismatch");
+    });
+
+    addFact("^ - 0x ^ Unsigned-real", function() {
+        var result_ct = 0xA7 ^ 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "0x ^ Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ^ Unsigned-real :: type mismatch");
+    });
+
+    addFact("^ - 0x ^ Signed-real", function() {
+        var result_ct = 0xA7 ^ 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "0x ^ Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ^ Signed-real :: type mismatch");
+    });
+
+    addFact("^ - Unsigned-real ^ 0b", function() {
+        var result_ct = 167 ^ 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ^ 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ^ 0b :: type mismatch");
+    });
+
+    addFact("^ - Unsigned-real ^ 0x", function() {
+        var result_ct = 167 ^ 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ^ 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ^ 0x :: type mismatch");
+    });
+
+    addFact("^ - Unsigned-real ^ Unsigned-real", function() {
+        var result_ct = 167 ^ 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ^ Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ^ Unsigned-real :: type mismatch");
+    });
+
+    addFact("^ - Unsigned-real ^ Signed-real", function() {
+        var result_ct = 167 ^ 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ^ Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ^ Signed-real :: type mismatch");
+    });
+
+    addFact("^ - Signed-real ^ 0b", function() {
+        var result_ct = 1.5 ^ 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ^ 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ^ 0b :: type mismatch");
+    });
+
+    addFact("^ - Signed-real ^ 0x", function() {
+        var result_ct = 1.5 ^ 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ^ 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ^ 0x :: type mismatch");
+    });
+
+    addFact("^ - Signed-real ^ Unsigned-real", function() {
+        var result_ct = 1.5 ^ 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ^ Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ^ Unsigned-real :: type mismatch");
+    });
+
+    addFact("^ - Signed-real ^ Signed-real", function() {
+        var result_ct = 1.5 ^ 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a ^ b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ^ Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ^ Signed-real :: type mismatch");
+    });
+
+    addFact("<< - 0b << 0b", function() {
+        var result_ct = 0b1011 << 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "0b << 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b << 0b :: type mismatch");
+    });
+
+    addFact("<< - 0b << 0x", function() {
+        var result_ct = 0b1011 << 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "0b << 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b << 0x :: type mismatch");
+    });
+
+    addFact("<< - 0b << Unsigned-real", function() {
+        var result_ct = 0b1011 << 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "0b << Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b << Unsigned-real :: type mismatch");
+    });
+
+    addFact("<< - 0b << Signed-real", function() {
+        var result_ct = 0b1011 << 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "0b << Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b << Signed-real :: type mismatch");
+    });
+
+    addFact("<< - 0x << 0b", function() {
+        var result_ct = 0xA7 << 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "0x << 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x << 0b :: type mismatch");
+    });
+
+    addFact("<< - 0x << 0x", function() {
+        var result_ct = 0xA7 << 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "0x << 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x << 0x :: type mismatch");
+    });
+
+    addFact("<< - 0x << Unsigned-real", function() {
+        var result_ct = 0xA7 << 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "0x << Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x << Unsigned-real :: type mismatch");
+    });
+
+    addFact("<< - 0x << Signed-real", function() {
+        var result_ct = 0xA7 << 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "0x << Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x << Signed-real :: type mismatch");
+    });
+
+    addFact("<< - Unsigned-real << 0b", function() {
+        var result_ct = 167 << 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real << 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real << 0b :: type mismatch");
+    });
+
+    addFact("<< - Unsigned-real << 0x", function() {
+        var result_ct = 167 << 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real << 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real << 0x :: type mismatch");
+    });
+
+    addFact("<< - Unsigned-real << Unsigned-real", function() {
+        var result_ct = 167 << 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real << Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real << Unsigned-real :: type mismatch");
+    });
+
+    addFact("<< - Unsigned-real << Signed-real", function() {
+        var result_ct = 167 << 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real << Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real << Signed-real :: type mismatch");
+    });
+
+    addFact("<< - Signed-real << 0b", function() {
+        var result_ct = 1.5 << 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real << 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real << 0b :: type mismatch");
+    });
+
+    addFact("<< - Signed-real << 0x", function() {
+        var result_ct = 1.5 << 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real << 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real << 0x :: type mismatch");
+    });
+
+    addFact("<< - Signed-real << Unsigned-real", function() {
+        var result_ct = 1.5 << 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real << Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real << Unsigned-real :: type mismatch");
+    });
+
+    addFact("<< - Signed-real << Signed-real", function() {
+        var result_ct = 1.5 << 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a << b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real << Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real << Signed-real :: type mismatch");
+    });
+
+    addFact(">> - 0b >> 0b", function() {
+        var result_ct = 0b1011 >> 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "0b >> 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b >> 0b :: type mismatch");
+    });
+
+    addFact(">> - 0b >> 0x", function() {
+        var result_ct = 0b1011 >> 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "0b >> 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b >> 0x :: type mismatch");
+    });
+
+    addFact(">> - 0b >> Unsigned-real", function() {
+        var result_ct = 0b1011 >> 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "0b >> Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b >> Unsigned-real :: type mismatch");
+    });
+
+    addFact(">> - 0b >> Signed-real", function() {
+        var result_ct = 0b1011 >> 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "0b >> Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b >> Signed-real :: type mismatch");
+    });
+
+    addFact(">> - 0x >> 0b", function() {
+        var result_ct = 0xA7 >> 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "0x >> 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x >> 0b :: type mismatch");
+    });
+
+    addFact(">> - 0x >> 0x", function() {
+        var result_ct = 0xA7 >> 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "0x >> 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x >> 0x :: type mismatch");
+    });
+
+    addFact(">> - 0x >> Unsigned-real", function() {
+        var result_ct = 0xA7 >> 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "0x >> Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x >> Unsigned-real :: type mismatch");
+    });
+
+    addFact(">> - 0x >> Signed-real", function() {
+        var result_ct = 0xA7 >> 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "0x >> Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x >> Signed-real :: type mismatch");
+    });
+
+    addFact(">> - Unsigned-real >> 0b", function() {
+        var result_ct = 167 >> 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real >> 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real >> 0b :: type mismatch");
+    });
+
+    addFact(">> - Unsigned-real >> 0x", function() {
+        var result_ct = 167 >> 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real >> 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real >> 0x :: type mismatch");
+    });
+
+    addFact(">> - Unsigned-real >> Unsigned-real", function() {
+        var result_ct = 167 >> 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real >> Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real >> Unsigned-real :: type mismatch");
+    });
+
+    addFact(">> - Unsigned-real >> Signed-real", function() {
+        var result_ct = 167 >> 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real >> Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real >> Signed-real :: type mismatch");
+    });
+
+    addFact(">> - Signed-real >> 0b", function() {
+        var result_ct = 1.5 >> 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real >> 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real >> 0b :: type mismatch");
+    });
+
+    addFact(">> - Signed-real >> 0x", function() {
+        var result_ct = 1.5 >> 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real >> 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real >> 0x :: type mismatch");
+    });
+
+    addFact(">> - Signed-real >> Unsigned-real", function() {
+        var result_ct = 1.5 >> 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real >> Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real >> Unsigned-real :: type mismatch");
+    });
+
+    addFact(">> - Signed-real >> Signed-real", function() {
+        var result_ct = 1.5 >> 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a >> b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real >> Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real >> Signed-real :: type mismatch");
+    });
+
+    addFact("+ - 0b + 0b", function() {
+        var result_ct = 0b1011 + 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "0b + 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b + 0b :: type mismatch");
+    });
+
+    addFact("+ - 0b + 0x", function() {
+        var result_ct = 0b1011 + 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "0b + 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b + 0x :: type mismatch");
+    });
+
+    addFact("+ - 0b + Unsigned-real", function() {
+        var result_ct = 0b1011 + 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "0b + Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b + Unsigned-real :: type mismatch");
+    });
+
+    addFact("+ - 0b + Signed-real", function() {
+        var result_ct = 0b1011 + 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "0b + Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b + Signed-real :: type mismatch");
+    });
+
+    addFact("+ - 0x + 0b", function() {
+        var result_ct = 0xA7 + 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "0x + 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x + 0b :: type mismatch");
+    });
+
+    addFact("+ - 0x + 0x", function() {
+        var result_ct = 0xA7 + 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "0x + 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x + 0x :: type mismatch");
+    });
+
+    addFact("+ - 0x + Unsigned-real", function() {
+        var result_ct = 0xA7 + 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "0x + Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x + Unsigned-real :: type mismatch");
+    });
+
+    addFact("+ - 0x + Signed-real", function() {
+        var result_ct = 0xA7 + 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "0x + Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x + Signed-real :: type mismatch");
+    });
+
+    addFact("+ - Unsigned-real + 0b", function() {
+        var result_ct = 167 + 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real + 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real + 0b :: type mismatch");
+    });
+
+    addFact("+ - Unsigned-real + 0x", function() {
+        var result_ct = 167 + 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real + 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real + 0x :: type mismatch");
+    });
+
+    addFact("+ - Unsigned-real + Unsigned-real", function() {
+        var result_ct = 167 + 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real + Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real + Unsigned-real :: type mismatch");
+    });
+
+    addFact("+ - Unsigned-real + Signed-real", function() {
+        var result_ct = 167 + 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real + Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real + Signed-real :: type mismatch");
+    });
+
+    addFact("+ - Signed-real + 0b", function() {
+        var result_ct = 1.5 + 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real + 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real + 0b :: type mismatch");
+    });
+
+    addFact("+ - Signed-real + 0x", function() {
+        var result_ct = 1.5 + 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real + 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real + 0x :: type mismatch");
+    });
+
+    addFact("+ - Signed-real + Unsigned-real", function() {
+        var result_ct = 1.5 + 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real + Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real + Unsigned-real :: type mismatch");
+    });
+
+    addFact("+ - Signed-real + Signed-real", function() {
+        var result_ct = 1.5 + 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a + b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real + Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real + Signed-real :: type mismatch");
+    });
+
+    addFact("- - 0b - 0b", function() {
+        var result_ct = 0b1011 - 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "0b - 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b - 0b :: type mismatch");
+    });
+
+    addFact("- - 0b - 0x", function() {
+        var result_ct = 0b1011 - 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "0b - 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b - 0x :: type mismatch");
+    });
+
+    addFact("- - 0b - Unsigned-real", function() {
+        var result_ct = 0b1011 - 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "0b - Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b - Unsigned-real :: type mismatch");
+    });
+
+    addFact("- - 0b - Signed-real", function() {
+        var result_ct = 0b1011 - 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "0b - Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b - Signed-real :: type mismatch");
+    });
+
+    addFact("- - 0x - 0b", function() {
+        var result_ct = 0xA7 - 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "0x - 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x - 0b :: type mismatch");
+    });
+
+    addFact("- - 0x - 0x", function() {
+        var result_ct = 0xA7 - 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "0x - 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x - 0x :: type mismatch");
+    });
+
+    addFact("- - 0x - Unsigned-real", function() {
+        var result_ct = 0xA7 - 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "0x - Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x - Unsigned-real :: type mismatch");
+    });
+
+    addFact("- - 0x - Signed-real", function() {
+        var result_ct = 0xA7 - 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "0x - Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x - Signed-real :: type mismatch");
+    });
+
+    addFact("- - Unsigned-real - 0b", function() {
+        var result_ct = 167 - 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real - 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real - 0b :: type mismatch");
+    });
+
+    addFact("- - Unsigned-real - 0x", function() {
+        var result_ct = 167 - 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real - 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real - 0x :: type mismatch");
+    });
+
+    addFact("- - Unsigned-real - Unsigned-real", function() {
+        var result_ct = 167 - 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real - Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real - Unsigned-real :: type mismatch");
+    });
+
+    addFact("- - Unsigned-real - Signed-real", function() {
+        var result_ct = 167 - 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real - Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real - Signed-real :: type mismatch");
+    });
+
+    addFact("- - Signed-real - 0b", function() {
+        var result_ct = 1.5 - 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real - 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real - 0b :: type mismatch");
+    });
+
+    addFact("- - Signed-real - 0x", function() {
+        var result_ct = 1.5 - 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real - 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real - 0x :: type mismatch");
+    });
+
+    addFact("- - Signed-real - Unsigned-real", function() {
+        var result_ct = 1.5 - 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real - Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real - Unsigned-real :: type mismatch");
+    });
+
+    addFact("- - Signed-real - Signed-real", function() {
+        var result_ct = 1.5 - 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a - b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real - Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real - Signed-real :: type mismatch");
+    });
+
+    addFact("* - 0b * 0b", function() {
+        var result_ct = 0b1011 * 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "0b * 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b * 0b :: type mismatch");
+    });
+
+    addFact("* - 0b * 0x", function() {
+        var result_ct = 0b1011 * 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "0b * 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b * 0x :: type mismatch");
+    });
+
+    addFact("* - 0b * Unsigned-real", function() {
+        var result_ct = 0b1011 * 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "0b * Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b * Unsigned-real :: type mismatch");
+    });
+
+    addFact("* - 0b * Signed-real", function() {
+        var result_ct = 0b1011 * 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "0b * Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b * Signed-real :: type mismatch");
+    });
+
+    addFact("* - 0x * 0b", function() {
+        var result_ct = 0xA7 * 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "0x * 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x * 0b :: type mismatch");
+    });
+
+    addFact("* - 0x * 0x", function() {
+        var result_ct = 0xA7 * 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "0x * 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x * 0x :: type mismatch");
+    });
+
+    addFact("* - 0x * Unsigned-real", function() {
+        var result_ct = 0xA7 * 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "0x * Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x * Unsigned-real :: type mismatch");
+    });
+
+    addFact("* - 0x * Signed-real", function() {
+        var result_ct = 0xA7 * 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "0x * Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x * Signed-real :: type mismatch");
+    });
+
+    addFact("* - Unsigned-real * 0b", function() {
+        var result_ct = 167 * 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real * 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real * 0b :: type mismatch");
+    });
+
+    addFact("* - Unsigned-real * 0x", function() {
+        var result_ct = 167 * 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real * 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real * 0x :: type mismatch");
+    });
+
+    addFact("* - Unsigned-real * Unsigned-real", function() {
+        var result_ct = 167 * 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real * Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real * Unsigned-real :: type mismatch");
+    });
+
+    addFact("* - Unsigned-real * Signed-real", function() {
+        var result_ct = 167 * 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real * Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real * Signed-real :: type mismatch");
+    });
+
+    addFact("* - Signed-real * 0b", function() {
+        var result_ct = 1.5 * 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real * 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real * 0b :: type mismatch");
+    });
+
+    addFact("* - Signed-real * 0x", function() {
+        var result_ct = 1.5 * 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real * 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real * 0x :: type mismatch");
+    });
+
+    addFact("* - Signed-real * Unsigned-real", function() {
+        var result_ct = 1.5 * 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real * Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real * Unsigned-real :: type mismatch");
+    });
+
+    addFact("* - Signed-real * Signed-real", function() {
+        var result_ct = 1.5 * 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a * b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real * Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real * Signed-real :: type mismatch");
+    });
+
+    addFact("/ - 0b / 0b", function() {
+        var result_ct = 0b1011 / 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "0b / 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b / 0b :: type mismatch");
+    });
+
+    addFact("/ - 0b / 0x", function() {
+        var result_ct = 0b1011 / 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "0b / 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b / 0x :: type mismatch");
+    });
+
+    addFact("/ - 0b / Unsigned-real", function() {
+        var result_ct = 0b1011 / 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "0b / Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b / Unsigned-real :: type mismatch");
+    });
+
+    addFact("/ - 0b / Signed-real", function() {
+        var result_ct = 0b1011 / 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "0b / Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b / Signed-real :: type mismatch");
+    });
+
+    addFact("/ - 0x / 0b", function() {
+        var result_ct = 0xA7 / 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "0x / 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x / 0b :: type mismatch");
+    });
+
+    addFact("/ - 0x / 0x", function() {
+        var result_ct = 0xA7 / 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "0x / 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x / 0x :: type mismatch");
+    });
+
+    addFact("/ - 0x / Unsigned-real", function() {
+        var result_ct = 0xA7 / 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "0x / Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x / Unsigned-real :: type mismatch");
+    });
+
+    addFact("/ - 0x / Signed-real", function() {
+        var result_ct = 0xA7 / 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "0x / Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x / Signed-real :: type mismatch");
+    });
+
+    addFact("/ - Unsigned-real / 0b", function() {
+        var result_ct = 167 / 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real / 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real / 0b :: type mismatch");
+    });
+
+    addFact("/ - Unsigned-real / 0x", function() {
+        var result_ct = 167 / 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real / 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real / 0x :: type mismatch");
+    });
+
+    addFact("/ - Unsigned-real / Unsigned-real", function() {
+        var result_ct = 167 / 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real / Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real / Unsigned-real :: type mismatch");
+    });
+
+    addFact("/ - Unsigned-real / Signed-real", function() {
+        var result_ct = 167 / 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real / Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real / Signed-real :: type mismatch");
+    });
+
+    addFact("/ - Signed-real / 0b", function() {
+        var result_ct = 1.5 / 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real / 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real / 0b :: type mismatch");
+    });
+
+    addFact("/ - Signed-real / 0x", function() {
+        var result_ct = 1.5 / 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real / 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real / 0x :: type mismatch");
+    });
+
+    addFact("/ - Signed-real / Unsigned-real", function() {
+        var result_ct = 1.5 / 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real / Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real / Unsigned-real :: type mismatch");
+    });
+
+    addFact("/ - Signed-real / Signed-real", function() {
+        var result_ct = 1.5 / 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a / b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real / Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real / Signed-real :: type mismatch");
+    });
+
+    addFact("% - 0b % 0b", function() {
+        var result_ct = 0b1011 % 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "0b % 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b % 0b :: type mismatch");
+    });
+
+    addFact("% - 0b % 0x", function() {
+        var result_ct = 0b1011 % 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "0b % 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b % 0x :: type mismatch");
+    });
+
+    addFact("% - 0b % Unsigned-real", function() {
+        var result_ct = 0b1011 % 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "0b % Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b % Unsigned-real :: type mismatch");
+    });
+
+    addFact("% - 0b % Signed-real", function() {
+        var result_ct = 0b1011 % 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "0b % Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b % Signed-real :: type mismatch");
+    });
+
+    addFact("% - 0x % 0b", function() {
+        var result_ct = 0xA7 % 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "0x % 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x % 0b :: type mismatch");
+    });
+
+    addFact("% - 0x % 0x", function() {
+        var result_ct = 0xA7 % 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "0x % 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x % 0x :: type mismatch");
+    });
+
+    addFact("% - 0x % Unsigned-real", function() {
+        var result_ct = 0xA7 % 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "0x % Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x % Unsigned-real :: type mismatch");
+    });
+
+    addFact("% - 0x % Signed-real", function() {
+        var result_ct = 0xA7 % 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "0x % Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x % Signed-real :: type mismatch");
+    });
+
+    addFact("% - Unsigned-real % 0b", function() {
+        var result_ct = 167 % 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real % 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real % 0b :: type mismatch");
+    });
+
+    addFact("% - Unsigned-real % 0x", function() {
+        var result_ct = 167 % 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real % 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real % 0x :: type mismatch");
+    });
+
+    addFact("% - Unsigned-real % Unsigned-real", function() {
+        var result_ct = 167 % 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real % Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real % Unsigned-real :: type mismatch");
+    });
+
+    addFact("% - Unsigned-real % Signed-real", function() {
+        var result_ct = 167 % 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real % Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real % Signed-real :: type mismatch");
+    });
+
+    addFact("% - Signed-real % 0b", function() {
+        var result_ct = 1.5 % 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real % 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real % 0b :: type mismatch");
+    });
+
+    addFact("% - Signed-real % 0x", function() {
+        var result_ct = 1.5 % 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real % 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real % 0x :: type mismatch");
+    });
+
+    addFact("% - Signed-real % Unsigned-real", function() {
+        var result_ct = 1.5 % 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real % Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real % Unsigned-real :: type mismatch");
+    });
+
+    addFact("% - Signed-real % Signed-real", function() {
+        var result_ct = 1.5 % 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a % b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real % Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real % Signed-real :: type mismatch");
+    });
+
+    addFact("div - 0b div 0b", function() {
+        var result_ct = 0b1011 div 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "0b div 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b div 0b :: type mismatch");
+    });
+
+    addFact("div - 0b div 0x", function() {
+        var result_ct = 0b1011 div 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "0b div 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b div 0x :: type mismatch");
+    });
+
+    addFact("div - 0b div Unsigned-real", function() {
+        var result_ct = 0b1011 div 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "0b div Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b div Unsigned-real :: type mismatch");
+    });
+
+    addFact("div - 0b div Signed-real", function() {
+        var result_ct = 0b1011 div 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "0b div Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b div Signed-real :: type mismatch");
+    });
+
+    addFact("div - 0x div 0b", function() {
+        var result_ct = 0xA7 div 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "0x div 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x div 0b :: type mismatch");
+    });
+
+    addFact("div - 0x div 0x", function() {
+        var result_ct = 0xA7 div 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "0x div 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x div 0x :: type mismatch");
+    });
+
+    addFact("div - 0x div Unsigned-real", function() {
+        var result_ct = 0xA7 div 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "0x div Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x div Unsigned-real :: type mismatch");
+    });
+
+    addFact("div - 0x div Signed-real", function() {
+        var result_ct = 0xA7 div 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "0x div Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x div Signed-real :: type mismatch");
+    });
+
+    addFact("div - Unsigned-real div 0b", function() {
+        var result_ct = 167 div 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real div 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real div 0b :: type mismatch");
+    });
+
+    addFact("div - Unsigned-real div 0x", function() {
+        var result_ct = 167 div 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real div 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real div 0x :: type mismatch");
+    });
+
+    addFact("div - Unsigned-real div Unsigned-real", function() {
+        var result_ct = 167 div 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real div Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real div Unsigned-real :: type mismatch");
+    });
+
+    addFact("div - Unsigned-real div Signed-real", function() {
+        var result_ct = 167 div 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real div Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real div Signed-real :: type mismatch");
+    });
+
+    addFact("div - Signed-real div 0b", function() {
+        var result_ct = 1.5 div 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real div 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real div 0b :: type mismatch");
+    });
+
+    addFact("div - Signed-real div 0x", function() {
+        var result_ct = 1.5 div 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real div 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real div 0x :: type mismatch");
+    });
+
+    addFact("div - Signed-real div Unsigned-real", function() {
+        var result_ct = 1.5 div 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real div Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real div Unsigned-real :: type mismatch");
+    });
+
+    addFact("div - Signed-real div Signed-real", function() {
+        var result_ct = 1.5 div 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a div b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real div Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real div Signed-real :: type mismatch");
+    });
+
+    addFact("mod - 0b mod 0b", function() {
+        var result_ct = 0b1011 mod 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "0b mod 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b mod 0b :: type mismatch");
+    });
+
+    addFact("mod - 0b mod 0x", function() {
+        var result_ct = 0b1011 mod 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "0b mod 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b mod 0x :: type mismatch");
+    });
+
+    addFact("mod - 0b mod Unsigned-real", function() {
+        var result_ct = 0b1011 mod 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "0b mod Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b mod Unsigned-real :: type mismatch");
+    });
+
+    addFact("mod - 0b mod Signed-real", function() {
+        var result_ct = 0b1011 mod 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "0b mod Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b mod Signed-real :: type mismatch");
+    });
+
+    addFact("mod - 0x mod 0b", function() {
+        var result_ct = 0xA7 mod 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "0x mod 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x mod 0b :: type mismatch");
+    });
+
+    addFact("mod - 0x mod 0x", function() {
+        var result_ct = 0xA7 mod 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "0x mod 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x mod 0x :: type mismatch");
+    });
+
+    addFact("mod - 0x mod Unsigned-real", function() {
+        var result_ct = 0xA7 mod 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "0x mod Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x mod Unsigned-real :: type mismatch");
+    });
+
+    addFact("mod - 0x mod Signed-real", function() {
+        var result_ct = 0xA7 mod 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "0x mod Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x mod Signed-real :: type mismatch");
+    });
+
+    addFact("mod - Unsigned-real mod 0b", function() {
+        var result_ct = 167 mod 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real mod 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real mod 0b :: type mismatch");
+    });
+
+    addFact("mod - Unsigned-real mod 0x", function() {
+        var result_ct = 167 mod 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real mod 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real mod 0x :: type mismatch");
+    });
+
+    addFact("mod - Unsigned-real mod Unsigned-real", function() {
+        var result_ct = 167 mod 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real mod Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real mod Unsigned-real :: type mismatch");
+    });
+
+    addFact("mod - Unsigned-real mod Signed-real", function() {
+        var result_ct = 167 mod 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real mod Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real mod Signed-real :: type mismatch");
+    });
+
+    addFact("mod - Signed-real mod 0b", function() {
+        var result_ct = 1.5 mod 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real mod 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real mod 0b :: type mismatch");
+    });
+
+    addFact("mod - Signed-real mod 0x", function() {
+        var result_ct = 1.5 mod 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real mod 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real mod 0x :: type mismatch");
+    });
+
+    addFact("mod - Signed-real mod Unsigned-real", function() {
+        var result_ct = 1.5 mod 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real mod Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real mod Unsigned-real :: type mismatch");
+    });
+
+    addFact("mod - Signed-real mod Signed-real", function() {
+        var result_ct = 1.5 mod 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a mod b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real mod Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real mod Signed-real :: type mismatch");
+    });
+
+    addFact("== - 0b == 0b", function() {
+        var result_ct = 0b1011 == 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "0b == 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b == 0b :: type mismatch");
+    });
+
+    addFact("== - 0b == 0x", function() {
+        var result_ct = 0b1011 == 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "0b == 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b == 0x :: type mismatch");
+    });
+
+    addFact("== - 0b == Unsigned-real", function() {
+        var result_ct = 0b1011 == 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "0b == Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b == Unsigned-real :: type mismatch");
+    });
+
+    addFact("== - 0b == Signed-real", function() {
+        var result_ct = 0b1011 == 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "0b == Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b == Signed-real :: type mismatch");
+    });
+
+    addFact("== - 0x == 0b", function() {
+        var result_ct = 0xA7 == 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "0x == 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x == 0b :: type mismatch");
+    });
+
+    addFact("== - 0x == 0x", function() {
+        var result_ct = 0xA7 == 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "0x == 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x == 0x :: type mismatch");
+    });
+
+    addFact("== - 0x == Unsigned-real", function() {
+        var result_ct = 0xA7 == 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "0x == Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x == Unsigned-real :: type mismatch");
+    });
+
+    addFact("== - 0x == Signed-real", function() {
+        var result_ct = 0xA7 == 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "0x == Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x == Signed-real :: type mismatch");
+    });
+
+    addFact("== - Unsigned-real == 0b", function() {
+        var result_ct = 167 == 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real == 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real == 0b :: type mismatch");
+    });
+
+    addFact("== - Unsigned-real == 0x", function() {
+        var result_ct = 167 == 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real == 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real == 0x :: type mismatch");
+    });
+
+    addFact("== - Unsigned-real == Unsigned-real", function() {
+        var result_ct = 167 == 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real == Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real == Unsigned-real :: type mismatch");
+    });
+
+    addFact("== - Unsigned-real == Signed-real", function() {
+        var result_ct = 167 == 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real == Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real == Signed-real :: type mismatch");
+    });
+
+    addFact("== - Signed-real == 0b", function() {
+        var result_ct = 1.5 == 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real == 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real == 0b :: type mismatch");
+    });
+
+    addFact("== - Signed-real == 0x", function() {
+        var result_ct = 1.5 == 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real == 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real == 0x :: type mismatch");
+    });
+
+    addFact("== - Signed-real == Unsigned-real", function() {
+        var result_ct = 1.5 == 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real == Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real == Unsigned-real :: type mismatch");
+    });
+
+    addFact("== - Signed-real == Signed-real", function() {
+        var result_ct = 1.5 == 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a == b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real == Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real == Signed-real :: type mismatch");
+    });
+
+    addFact("!= - 0b != 0b", function() {
+        var result_ct = 0b1011 != 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "0b != 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b != 0b :: type mismatch");
+    });
+
+    addFact("!= - 0b != 0x", function() {
+        var result_ct = 0b1011 != 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "0b != 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b != 0x :: type mismatch");
+    });
+
+    addFact("!= - 0b != Unsigned-real", function() {
+        var result_ct = 0b1011 != 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "0b != Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b != Unsigned-real :: type mismatch");
+    });
+
+    addFact("!= - 0b != Signed-real", function() {
+        var result_ct = 0b1011 != 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "0b != Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b != Signed-real :: type mismatch");
+    });
+
+    addFact("!= - 0x != 0b", function() {
+        var result_ct = 0xA7 != 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "0x != 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x != 0b :: type mismatch");
+    });
+
+    addFact("!= - 0x != 0x", function() {
+        var result_ct = 0xA7 != 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "0x != 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x != 0x :: type mismatch");
+    });
+
+    addFact("!= - 0x != Unsigned-real", function() {
+        var result_ct = 0xA7 != 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "0x != Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x != Unsigned-real :: type mismatch");
+    });
+
+    addFact("!= - 0x != Signed-real", function() {
+        var result_ct = 0xA7 != 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "0x != Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x != Signed-real :: type mismatch");
+    });
+
+    addFact("!= - Unsigned-real != 0b", function() {
+        var result_ct = 167 != 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real != 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real != 0b :: type mismatch");
+    });
+
+    addFact("!= - Unsigned-real != 0x", function() {
+        var result_ct = 167 != 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real != 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real != 0x :: type mismatch");
+    });
+
+    addFact("!= - Unsigned-real != Unsigned-real", function() {
+        var result_ct = 167 != 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real != Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real != Unsigned-real :: type mismatch");
+    });
+
+    addFact("!= - Unsigned-real != Signed-real", function() {
+        var result_ct = 167 != 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real != Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real != Signed-real :: type mismatch");
+    });
+
+    addFact("!= - Signed-real != 0b", function() {
+        var result_ct = 1.5 != 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real != 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real != 0b :: type mismatch");
+    });
+
+    addFact("!= - Signed-real != 0x", function() {
+        var result_ct = 1.5 != 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real != 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real != 0x :: type mismatch");
+    });
+
+    addFact("!= - Signed-real != Unsigned-real", function() {
+        var result_ct = 1.5 != 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real != Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real != Unsigned-real :: type mismatch");
+    });
+
+    addFact("!= - Signed-real != Signed-real", function() {
+        var result_ct = 1.5 != 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a != b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real != Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real != Signed-real :: type mismatch");
+    });
+
+    addFact("< - 0b < 0b", function() {
+        var result_ct = 0b1011 < 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "0b < 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b < 0b :: type mismatch");
+    });
+
+    addFact("< - 0b < 0x", function() {
+        var result_ct = 0b1011 < 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "0b < 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b < 0x :: type mismatch");
+    });
+
+    addFact("< - 0b < Unsigned-real", function() {
+        var result_ct = 0b1011 < 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "0b < Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b < Unsigned-real :: type mismatch");
+    });
+
+    addFact("< - 0b < Signed-real", function() {
+        var result_ct = 0b1011 < 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "0b < Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b < Signed-real :: type mismatch");
+    });
+
+    addFact("< - 0x < 0b", function() {
+        var result_ct = 0xA7 < 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "0x < 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x < 0b :: type mismatch");
+    });
+
+    addFact("< - 0x < 0x", function() {
+        var result_ct = 0xA7 < 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "0x < 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x < 0x :: type mismatch");
+    });
+
+    addFact("< - 0x < Unsigned-real", function() {
+        var result_ct = 0xA7 < 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "0x < Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x < Unsigned-real :: type mismatch");
+    });
+
+    addFact("< - 0x < Signed-real", function() {
+        var result_ct = 0xA7 < 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "0x < Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x < Signed-real :: type mismatch");
+    });
+
+    addFact("< - Unsigned-real < 0b", function() {
+        var result_ct = 167 < 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real < 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real < 0b :: type mismatch");
+    });
+
+    addFact("< - Unsigned-real < 0x", function() {
+        var result_ct = 167 < 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real < 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real < 0x :: type mismatch");
+    });
+
+    addFact("< - Unsigned-real < Unsigned-real", function() {
+        var result_ct = 167 < 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real < Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real < Unsigned-real :: type mismatch");
+    });
+
+    addFact("< - Unsigned-real < Signed-real", function() {
+        var result_ct = 167 < 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real < Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real < Signed-real :: type mismatch");
+    });
+
+    addFact("< - Signed-real < 0b", function() {
+        var result_ct = 1.5 < 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real < 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real < 0b :: type mismatch");
+    });
+
+    addFact("< - Signed-real < 0x", function() {
+        var result_ct = 1.5 < 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real < 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real < 0x :: type mismatch");
+    });
+
+    addFact("< - Signed-real < Unsigned-real", function() {
+        var result_ct = 1.5 < 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real < Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real < Unsigned-real :: type mismatch");
+    });
+
+    addFact("< - Signed-real < Signed-real", function() {
+        var result_ct = 1.5 < 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a < b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real < Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real < Signed-real :: type mismatch");
+    });
+
+    addFact("> - 0b > 0b", function() {
+        var result_ct = 0b1011 > 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "0b > 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b > 0b :: type mismatch");
+    });
+
+    addFact("> - 0b > 0x", function() {
+        var result_ct = 0b1011 > 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "0b > 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b > 0x :: type mismatch");
+    });
+
+    addFact("> - 0b > Unsigned-real", function() {
+        var result_ct = 0b1011 > 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "0b > Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b > Unsigned-real :: type mismatch");
+    });
+
+    addFact("> - 0b > Signed-real", function() {
+        var result_ct = 0b1011 > 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "0b > Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b > Signed-real :: type mismatch");
+    });
+
+    addFact("> - 0x > 0b", function() {
+        var result_ct = 0xA7 > 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "0x > 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x > 0b :: type mismatch");
+    });
+
+    addFact("> - 0x > 0x", function() {
+        var result_ct = 0xA7 > 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "0x > 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x > 0x :: type mismatch");
+    });
+
+    addFact("> - 0x > Unsigned-real", function() {
+        var result_ct = 0xA7 > 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "0x > Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x > Unsigned-real :: type mismatch");
+    });
+
+    addFact("> - 0x > Signed-real", function() {
+        var result_ct = 0xA7 > 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "0x > Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x > Signed-real :: type mismatch");
+    });
+
+    addFact("> - Unsigned-real > 0b", function() {
+        var result_ct = 167 > 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real > 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real > 0b :: type mismatch");
+    });
+
+    addFact("> - Unsigned-real > 0x", function() {
+        var result_ct = 167 > 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real > 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real > 0x :: type mismatch");
+    });
+
+    addFact("> - Unsigned-real > Unsigned-real", function() {
+        var result_ct = 167 > 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real > Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real > Unsigned-real :: type mismatch");
+    });
+
+    addFact("> - Unsigned-real > Signed-real", function() {
+        var result_ct = 167 > 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real > Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real > Signed-real :: type mismatch");
+    });
+
+    addFact("> - Signed-real > 0b", function() {
+        var result_ct = 1.5 > 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real > 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real > 0b :: type mismatch");
+    });
+
+    addFact("> - Signed-real > 0x", function() {
+        var result_ct = 1.5 > 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real > 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real > 0x :: type mismatch");
+    });
+
+    addFact("> - Signed-real > Unsigned-real", function() {
+        var result_ct = 1.5 > 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real > Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real > Unsigned-real :: type mismatch");
+    });
+
+    addFact("> - Signed-real > Signed-real", function() {
+        var result_ct = 1.5 > 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a > b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real > Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real > Signed-real :: type mismatch");
+    });
+
+    addFact("<= - 0b <= 0b", function() {
+        var result_ct = 0b1011 <= 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "0b <= 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b <= 0b :: type mismatch");
+    });
+
+    addFact("<= - 0b <= 0x", function() {
+        var result_ct = 0b1011 <= 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "0b <= 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b <= 0x :: type mismatch");
+    });
+
+    addFact("<= - 0b <= Unsigned-real", function() {
+        var result_ct = 0b1011 <= 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "0b <= Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b <= Unsigned-real :: type mismatch");
+    });
+
+    addFact("<= - 0b <= Signed-real", function() {
+        var result_ct = 0b1011 <= 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "0b <= Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b <= Signed-real :: type mismatch");
+    });
+
+    addFact("<= - 0x <= 0b", function() {
+        var result_ct = 0xA7 <= 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "0x <= 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x <= 0b :: type mismatch");
+    });
+
+    addFact("<= - 0x <= 0x", function() {
+        var result_ct = 0xA7 <= 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "0x <= 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x <= 0x :: type mismatch");
+    });
+
+    addFact("<= - 0x <= Unsigned-real", function() {
+        var result_ct = 0xA7 <= 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "0x <= Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x <= Unsigned-real :: type mismatch");
+    });
+
+    addFact("<= - 0x <= Signed-real", function() {
+        var result_ct = 0xA7 <= 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "0x <= Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x <= Signed-real :: type mismatch");
+    });
+
+    addFact("<= - Unsigned-real <= 0b", function() {
+        var result_ct = 167 <= 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real <= 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real <= 0b :: type mismatch");
+    });
+
+    addFact("<= - Unsigned-real <= 0x", function() {
+        var result_ct = 167 <= 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real <= 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real <= 0x :: type mismatch");
+    });
+
+    addFact("<= - Unsigned-real <= Unsigned-real", function() {
+        var result_ct = 167 <= 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real <= Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real <= Unsigned-real :: type mismatch");
+    });
+
+    addFact("<= - Unsigned-real <= Signed-real", function() {
+        var result_ct = 167 <= 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real <= Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real <= Signed-real :: type mismatch");
+    });
+
+    addFact("<= - Signed-real <= 0b", function() {
+        var result_ct = 1.5 <= 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real <= 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real <= 0b :: type mismatch");
+    });
+
+    addFact("<= - Signed-real <= 0x", function() {
+        var result_ct = 1.5 <= 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real <= 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real <= 0x :: type mismatch");
+    });
+
+    addFact("<= - Signed-real <= Unsigned-real", function() {
+        var result_ct = 1.5 <= 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real <= Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real <= Unsigned-real :: type mismatch");
+    });
+
+    addFact("<= - Signed-real <= Signed-real", function() {
+        var result_ct = 1.5 <= 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a <= b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real <= Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real <= Signed-real :: type mismatch");
+    });
+
+    addFact(">= - 0b >= 0b", function() {
+        var result_ct = 0b1011 >= 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "0b >= 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b >= 0b :: type mismatch");
+    });
+
+    addFact(">= - 0b >= 0x", function() {
+        var result_ct = 0b1011 >= 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "0b >= 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b >= 0x :: type mismatch");
+    });
+
+    addFact(">= - 0b >= Unsigned-real", function() {
+        var result_ct = 0b1011 >= 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "0b >= Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b >= Unsigned-real :: type mismatch");
+    });
+
+    addFact(">= - 0b >= Signed-real", function() {
+        var result_ct = 0b1011 >= 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "0b >= Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b >= Signed-real :: type mismatch");
+    });
+
+    addFact(">= - 0x >= 0b", function() {
+        var result_ct = 0xA7 >= 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "0x >= 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x >= 0b :: type mismatch");
+    });
+
+    addFact(">= - 0x >= 0x", function() {
+        var result_ct = 0xA7 >= 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "0x >= 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x >= 0x :: type mismatch");
+    });
+
+    addFact(">= - 0x >= Unsigned-real", function() {
+        var result_ct = 0xA7 >= 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "0x >= Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x >= Unsigned-real :: type mismatch");
+    });
+
+    addFact(">= - 0x >= Signed-real", function() {
+        var result_ct = 0xA7 >= 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "0x >= Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x >= Signed-real :: type mismatch");
+    });
+
+    addFact(">= - Unsigned-real >= 0b", function() {
+        var result_ct = 167 >= 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real >= 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real >= 0b :: type mismatch");
+    });
+
+    addFact(">= - Unsigned-real >= 0x", function() {
+        var result_ct = 167 >= 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real >= 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real >= 0x :: type mismatch");
+    });
+
+    addFact(">= - Unsigned-real >= Unsigned-real", function() {
+        var result_ct = 167 >= 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real >= Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real >= Unsigned-real :: type mismatch");
+    });
+
+    addFact(">= - Unsigned-real >= Signed-real", function() {
+        var result_ct = 167 >= 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real >= Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real >= Signed-real :: type mismatch");
+    });
+
+    addFact(">= - Signed-real >= 0b", function() {
+        var result_ct = 1.5 >= 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real >= 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real >= 0b :: type mismatch");
+    });
+
+    addFact(">= - Signed-real >= 0x", function() {
+        var result_ct = 1.5 >= 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real >= 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real >= 0x :: type mismatch");
+    });
+
+    addFact(">= - Signed-real >= Unsigned-real", function() {
+        var result_ct = 1.5 >= 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real >= Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real >= Unsigned-real :: type mismatch");
+    });
+
+    addFact(">= - Signed-real >= Signed-real", function() {
+        var result_ct = 1.5 >= 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a >= b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real >= Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real >= Signed-real :: type mismatch");
+    });
+
+    addFact("&& - 0b && 0b", function() {
+        var result_ct = 0b1011 && 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "0b && 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b && 0b :: type mismatch");
+    });
+
+    addFact("&& - 0b && 0x", function() {
+        var result_ct = 0b1011 && 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "0b && 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b && 0x :: type mismatch");
+    });
+
+    addFact("&& - 0b && Unsigned-real", function() {
+        var result_ct = 0b1011 && 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "0b && Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b && Unsigned-real :: type mismatch");
+    });
+
+    addFact("&& - 0b && Signed-real", function() {
+        var result_ct = 0b1011 && 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "0b && Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b && Signed-real :: type mismatch");
+    });
+
+    addFact("&& - 0x && 0b", function() {
+        var result_ct = 0xA7 && 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "0x && 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x && 0b :: type mismatch");
+    });
+
+    addFact("&& - 0x && 0x", function() {
+        var result_ct = 0xA7 && 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "0x && 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x && 0x :: type mismatch");
+    });
+
+    addFact("&& - 0x && Unsigned-real", function() {
+        var result_ct = 0xA7 && 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "0x && Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x && Unsigned-real :: type mismatch");
+    });
+
+    addFact("&& - 0x && Signed-real", function() {
+        var result_ct = 0xA7 && 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "0x && Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x && Signed-real :: type mismatch");
+    });
+
+    addFact("&& - Unsigned-real && 0b", function() {
+        var result_ct = 167 && 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real && 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real && 0b :: type mismatch");
+    });
+
+    addFact("&& - Unsigned-real && 0x", function() {
+        var result_ct = 167 && 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real && 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real && 0x :: type mismatch");
+    });
+
+    addFact("&& - Unsigned-real && Unsigned-real", function() {
+        var result_ct = 167 && 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real && Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real && Unsigned-real :: type mismatch");
+    });
+
+    addFact("&& - Unsigned-real && Signed-real", function() {
+        var result_ct = 167 && 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real && Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real && Signed-real :: type mismatch");
+    });
+
+    addFact("&& - Signed-real && 0b", function() {
+        var result_ct = 1.5 && 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real && 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real && 0b :: type mismatch");
+    });
+
+    addFact("&& - Signed-real && 0x", function() {
+        var result_ct = 1.5 && 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real && 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real && 0x :: type mismatch");
+    });
+
+    addFact("&& - Signed-real && Unsigned-real", function() {
+        var result_ct = 1.5 && 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real && Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real && Unsigned-real :: type mismatch");
+    });
+
+    addFact("&& - Signed-real && Signed-real", function() {
+        var result_ct = 1.5 && 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a && b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real && Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real && Signed-real :: type mismatch");
+    });
+
+    addFact("|| - 0b || 0b", function() {
+        var result_ct = 0b1011 || 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "0b || 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b || 0b :: type mismatch");
+    });
+
+    addFact("|| - 0b || 0x", function() {
+        var result_ct = 0b1011 || 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "0b || 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b || 0x :: type mismatch");
+    });
+
+    addFact("|| - 0b || Unsigned-real", function() {
+        var result_ct = 0b1011 || 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "0b || Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b || Unsigned-real :: type mismatch");
+    });
+
+    addFact("|| - 0b || Signed-real", function() {
+        var result_ct = 0b1011 || 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "0b || Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b || Signed-real :: type mismatch");
+    });
+
+    addFact("|| - 0x || 0b", function() {
+        var result_ct = 0xA7 || 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "0x || 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x || 0b :: type mismatch");
+    });
+
+    addFact("|| - 0x || 0x", function() {
+        var result_ct = 0xA7 || 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "0x || 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x || 0x :: type mismatch");
+    });
+
+    addFact("|| - 0x || Unsigned-real", function() {
+        var result_ct = 0xA7 || 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "0x || Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x || Unsigned-real :: type mismatch");
+    });
+
+    addFact("|| - 0x || Signed-real", function() {
+        var result_ct = 0xA7 || 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "0x || Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x || Signed-real :: type mismatch");
+    });
+
+    addFact("|| - Unsigned-real || 0b", function() {
+        var result_ct = 167 || 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real || 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real || 0b :: type mismatch");
+    });
+
+    addFact("|| - Unsigned-real || 0x", function() {
+        var result_ct = 167 || 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real || 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real || 0x :: type mismatch");
+    });
+
+    addFact("|| - Unsigned-real || Unsigned-real", function() {
+        var result_ct = 167 || 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real || Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real || Unsigned-real :: type mismatch");
+    });
+
+    addFact("|| - Unsigned-real || Signed-real", function() {
+        var result_ct = 167 || 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real || Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real || Signed-real :: type mismatch");
+    });
+
+    addFact("|| - Signed-real || 0b", function() {
+        var result_ct = 1.5 || 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real || 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real || 0b :: type mismatch");
+    });
+
+    addFact("|| - Signed-real || 0x", function() {
+        var result_ct = 1.5 || 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real || 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real || 0x :: type mismatch");
+    });
+
+    addFact("|| - Signed-real || Unsigned-real", function() {
+        var result_ct = 1.5 || 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real || Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real || Unsigned-real :: type mismatch");
+    });
+
+    addFact("|| - Signed-real || Signed-real", function() {
+        var result_ct = 1.5 || 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a || b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real || Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real || Signed-real :: type mismatch");
+    });
+
+    addFact("^^ - 0b ^^ 0b", function() {
+        var result_ct = 0b1011 ^^ 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "0b ^^ 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ^^ 0b :: type mismatch");
+    });
+
+    addFact("^^ - 0b ^^ 0x", function() {
+        var result_ct = 0b1011 ^^ 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "0b ^^ 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ^^ 0x :: type mismatch");
+    });
+
+    addFact("^^ - 0b ^^ Unsigned-real", function() {
+        var result_ct = 0b1011 ^^ 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "0b ^^ Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ^^ Unsigned-real :: type mismatch");
+    });
+
+    addFact("^^ - 0b ^^ Signed-real", function() {
+        var result_ct = 0b1011 ^^ 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "0b ^^ Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ^^ Signed-real :: type mismatch");
+    });
+
+    addFact("^^ - 0x ^^ 0b", function() {
+        var result_ct = 0xA7 ^^ 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "0x ^^ 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ^^ 0b :: type mismatch");
+    });
+
+    addFact("^^ - 0x ^^ 0x", function() {
+        var result_ct = 0xA7 ^^ 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "0x ^^ 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ^^ 0x :: type mismatch");
+    });
+
+    addFact("^^ - 0x ^^ Unsigned-real", function() {
+        var result_ct = 0xA7 ^^ 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "0x ^^ Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ^^ Unsigned-real :: type mismatch");
+    });
+
+    addFact("^^ - 0x ^^ Signed-real", function() {
+        var result_ct = 0xA7 ^^ 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "0x ^^ Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ^^ Signed-real :: type mismatch");
+    });
+
+    addFact("^^ - Unsigned-real ^^ 0b", function() {
+        var result_ct = 167 ^^ 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ^^ 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ^^ 0b :: type mismatch");
+    });
+
+    addFact("^^ - Unsigned-real ^^ 0x", function() {
+        var result_ct = 167 ^^ 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ^^ 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ^^ 0x :: type mismatch");
+    });
+
+    addFact("^^ - Unsigned-real ^^ Unsigned-real", function() {
+        var result_ct = 167 ^^ 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ^^ Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ^^ Unsigned-real :: type mismatch");
+    });
+
+    addFact("^^ - Unsigned-real ^^ Signed-real", function() {
+        var result_ct = 167 ^^ 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ^^ Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ^^ Signed-real :: type mismatch");
+    });
+
+    addFact("^^ - Signed-real ^^ 0b", function() {
+        var result_ct = 1.5 ^^ 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ^^ 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ^^ 0b :: type mismatch");
+    });
+
+    addFact("^^ - Signed-real ^^ 0x", function() {
+        var result_ct = 1.5 ^^ 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ^^ 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ^^ 0x :: type mismatch");
+    });
+
+    addFact("^^ - Signed-real ^^ Unsigned-real", function() {
+        var result_ct = 1.5 ^^ 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ^^ Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ^^ Unsigned-real :: type mismatch");
+    });
+
+    addFact("^^ - Signed-real ^^ Signed-real", function() {
+        var result_ct = 1.5 ^^ 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a ^^ b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ^^ Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ^^ Signed-real :: type mismatch");
+    });
+
+    addFact("?? - 0b ?? 0b", function() {
+        var result_ct = 0b1011 ?? 0b1011;
+        var a = 0b1011;
+        var b = 0b1011;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "0b ?? 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ?? 0b :: type mismatch");
+    });
+
+    addFact("?? - 0b ?? 0x", function() {
+        var result_ct = 0b1011 ?? 0xA7;
+        var a = 0b1011;
+        var b = 0xA7;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "0b ?? 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ?? 0x :: type mismatch");
+    });
+
+    addFact("?? - 0b ?? Unsigned-real", function() {
+        var result_ct = 0b1011 ?? 167;
+        var a = 0b1011;
+        var b = 167;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "0b ?? Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ?? Unsigned-real :: type mismatch");
+    });
+
+    addFact("?? - 0b ?? Signed-real", function() {
+        var result_ct = 0b1011 ?? 1.5;
+        var a = 0b1011;
+        var b = 1.5;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "0b ?? Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0b ?? Signed-real :: type mismatch");
+    });
+
+    addFact("?? - 0x ?? 0b", function() {
+        var result_ct = 0xA7 ?? 0b1011;
+        var a = 0xA7;
+        var b = 0b1011;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "0x ?? 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ?? 0b :: type mismatch");
+    });
+
+    addFact("?? - 0x ?? 0x", function() {
+        var result_ct = 0xA7 ?? 0xA7;
+        var a = 0xA7;
+        var b = 0xA7;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "0x ?? 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ?? 0x :: type mismatch");
+    });
+
+    addFact("?? - 0x ?? Unsigned-real", function() {
+        var result_ct = 0xA7 ?? 167;
+        var a = 0xA7;
+        var b = 167;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "0x ?? Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ?? Unsigned-real :: type mismatch");
+    });
+
+    addFact("?? - 0x ?? Signed-real", function() {
+        var result_ct = 0xA7 ?? 1.5;
+        var a = 0xA7;
+        var b = 1.5;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "0x ?? Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "0x ?? Signed-real :: type mismatch");
+    });
+
+    addFact("?? - Unsigned-real ?? 0b", function() {
+        var result_ct = 167 ?? 0b1011;
+        var a = 167;
+        var b = 0b1011;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ?? 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ?? 0b :: type mismatch");
+    });
+
+    addFact("?? - Unsigned-real ?? 0x", function() {
+        var result_ct = 167 ?? 0xA7;
+        var a = 167;
+        var b = 0xA7;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ?? 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ?? 0x :: type mismatch");
+    });
+
+    addFact("?? - Unsigned-real ?? Unsigned-real", function() {
+        var result_ct = 167 ?? 167;
+        var a = 167;
+        var b = 167;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ?? Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ?? Unsigned-real :: type mismatch");
+    });
+
+    addFact("?? - Unsigned-real ?? Signed-real", function() {
+        var result_ct = 167 ?? 1.5;
+        var a = 167;
+        var b = 1.5;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "Unsigned-real ?? Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Unsigned-real ?? Signed-real :: type mismatch");
+    });
+
+    addFact("?? - Signed-real ?? 0b", function() {
+        var result_ct = 1.5 ?? 0b1011;
+        var a = 1.5;
+        var b = 0b1011;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ?? 0b :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ?? 0b :: type mismatch");
+    });
+
+    addFact("?? - Signed-real ?? 0x", function() {
+        var result_ct = 1.5 ?? 0xA7;
+        var a = 1.5;
+        var b = 0xA7;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ?? 0x :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ?? 0x :: type mismatch");
+    });
+
+    addFact("?? - Signed-real ?? Unsigned-real", function() {
+        var result_ct = 1.5 ?? 167;
+        var a = 1.5;
+        var b = 167;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ?? Unsigned-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ?? Unsigned-real :: type mismatch");
+    });
+
+    addFact("?? - Signed-real ?? Signed-real", function() {
+        var result_ct = 1.5 ?? 1.5;
+        var a = 1.5;
+        var b = 1.5;
+        var result_rt = a ?? b;
+
+        assert_equals(result_ct == result_rt, true, "Signed-real ?? Signed-real :: value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, "Signed-real ?? Signed-real :: type mismatch");
+    });
+#endregion
+#region === Unary Operators ===
+
+    addFact("! - !0b", function() {
+        var result_ct = !0b1011;
+        var a = 0b1011;
+        var result_rt = !a;
+
+        var name = "!0b";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("! - !0x", function() {
+        var result_ct = !0xA7;
+        var a = 0xA7;
+        var result_rt = !a;
+
+        var name = "!0x";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("! - !Unsigned-real", function() {
+        var result_ct = !167;
+        var a = 167;
+        var result_rt = !a;
+
+        var name = "!Unsigned-real";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("! - !Signed-real", function() {
+        var result_ct = !1.5;
+        var a = 1.5;
+        var result_rt = !a;
+
+        var name = "!Signed-real";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("- - -0b", function() {
+        var result_ct = -0b1011;
+        var a = 0b1011;
+        var result_rt = -a;
+
+        var name = "-0b";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("- - -0x", function() {
+        var result_ct = -0xA7;
+        var a = 0xA7;
+        var result_rt = -a;
+
+        var name = "-0x";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("- - -Unsigned-real", function() {
+        var result_ct = -167;
+        var a = 167;
+        var result_rt = -a;
+
+        var name = "-Unsigned-real";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("- - -Signed-real", function() {
+        var result_ct = -1.5;
+        var a = 1.5;
+        var result_rt = -a;
+
+        var name = "-Signed-real";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("~ - ~0b", function() {
+        var result_ct = ~0b1011;
+        var a = 0b1011;
+        var result_rt = ~a;
+
+        var name = "~0b";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("~ - ~0x", function() {
+        var result_ct = ~0xA7;
+        var a = 0xA7;
+        var result_rt = ~a;
+
+        var name = "~0x";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("~ - ~Unsigned-real", function() {
+        var result_ct = ~167;
+        var a = 167;
+        var result_rt = ~a;
+
+        var name = "~Unsigned-real";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+
+    addFact("~ - ~Signed-real", function() {
+        var result_ct = ~1.5;
+        var a = 1.5;
+        var result_rt = ~a;
+
+        var name = "~Signed-real";
+        assert_equals(result_ct == result_rt, true, name + ": value mismatch");
+        assert_equals(typeof(result_ct) == typeof(result_rt), true, name + ": type mismatch");
+    });
+#endregion
+#region === Single-Arg Functions ===
+
+    addFact("sin - Single Arg", function() {
+        var result_ct = sin(167.0);
+        var a = 167.0;
+        var result_rt = sin(a);
+
+        assert_equals(result_ct == result_rt, true, "sin(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "sin(167.0): type mismatch");
+    });
+
+    addFact("cos - Single Arg", function() {
+        var result_ct = cos(167.0);
+        var a = 167.0;
+        var result_rt = cos(a);
+
+        assert_equals(result_ct == result_rt, true, "cos(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "cos(167.0): type mismatch");
+    });
+
+    addFact("tan - Single Arg", function() {
+        var result_ct = tan(167.0);
+        var a = 167.0;
+        var result_rt = tan(a);
+
+        assert_equals(result_ct == result_rt, true, "tan(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "tan(167.0): type mismatch");
+    });
+
+    addFact("ceil - Single Arg", function() {
+        var result_ct = ceil(167.0);
+        var a = 167.0;
+        var result_rt = ceil(a);
+
+        assert_equals(result_ct == result_rt, true, "ceil(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "ceil(167.0): type mismatch");
+    });
+
+    addFact("floor - Single Arg", function() {
+        var result_ct = floor(167.0);
+        var a = 167.0;
+        var result_rt = floor(a);
+
+        assert_equals(result_ct == result_rt, true, "floor(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "floor(167.0): type mismatch");
+    });
+
+    addFact("abs - Single Arg", function() {
+        var result_ct = abs(167.0);
+        var a = 167.0;
+        var result_rt = abs(a);
+
+        assert_equals(result_ct == result_rt, true, "abs(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "abs(167.0): type mismatch");
+    });
+
+    addFact("sign - Single Arg", function() {
+        var result_ct = sign(167.0);
+        var a = 167.0;
+        var result_rt = sign(a);
+
+        assert_equals(result_ct == result_rt, true, "sign(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "sign(167.0): type mismatch");
+    });
+
+    addFact("frac - Single Arg", function() {
+        var result_ct = frac(167.0);
+        var a = 167.0;
+        var result_rt = frac(a);
+
+        assert_equals(result_ct == result_rt, true, "frac(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "frac(167.0): type mismatch");
+    });
+
+    addFact("sqr - Single Arg", function() {
+        var result_ct = sqr(167.0);
+        var a = 167.0;
+        var result_rt = sqr(a);
+
+        assert_equals(result_ct == result_rt, true, "sqr(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "sqr(167.0): type mismatch");
+    });
+
+    addFact("exp - Single Arg", function() {
+        var result_ct = exp(167.0);
+        var a = 167.0;
+        var result_rt = exp(a);
+
+        assert_equals(result_ct == result_rt, true, "exp(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "exp(167.0): type mismatch");
+    });
+
+    addFact("ln - Single Arg", function() {
+        var result_ct = ln(167.0);
+        var a = 167.0;
+        var result_rt = ln(a);
+
+        assert_equals(result_ct == result_rt, true, "ln(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "ln(167.0): type mismatch");
+    });
+
+    addFact("log2 - Single Arg", function() {
+        var result_ct = log2(167.0);
+        var a = 167.0;
+        var result_rt = log2(a);
+
+        assert_equals(result_ct == result_rt, true, "log2(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "log2(167.0): type mismatch");
+    });
+
+    addFact("log10 - Single Arg", function() {
+        var result_ct = log10(167.0);
+        var a = 167.0;
+        var result_rt = log10(a);
+
+        assert_equals(result_ct == result_rt, true, "log10(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "log10(167.0): type mismatch");
+    });
+
+    addFact("chr - Single Arg", function() {
+        var result_ct = chr(167.0);
+        var a = 167.0;
+        var result_rt = chr(a);
+
+        assert_equals(result_ct == result_rt, true, "chr(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "chr(167.0): type mismatch");
+    });
+
+    addFact("int64 - Single Arg", function() {
+        var result_ct = int64(167.0);
+        var a = 167.0;
+        var result_rt = int64(a);
+
+        assert_equals(result_ct == result_rt, true, "int64(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "int64(167.0): type mismatch");
+    });
+
+    addFact("real - Single Arg", function() {
+        var result_ct = real(167.0);
+        var a = 167.0;
+        var result_rt = real(a);
+
+        assert_equals(result_ct == result_rt, true, "real(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "real(167.0): type mismatch");
+    });
+
+    addFact("variable_get_hash - Single Arg", function() {
+        var result_ct = variable_get_hash(167.0);
+        var a = 167.0;
+        var result_rt = variable_get_hash(a);
+
+        assert_equals(result_ct == result_rt, true, "variable_get_hash(167.0): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "variable_get_hash(167.0): type mismatch");
+    });
+#endregion
+#region === Multi-Arg Functions ===
+
+    addFact("power - 2 Arg(s)", function() {
+        var result_ct = power(3, 7);
+		var a0 = 3;
+		var a1 = 7;
+        var result_rt = power(a0, a1);
+
+        assert_equals(result_ct == result_rt, true, "power(3, 7): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "power(3, 7): type mismatch");
+    });
+
+    addFact("min - 2 Arg(s)", function() {
+        var result_ct = min(3, 7);
+		var a0 = 3;
+		var a1 = 7;
+        var result_rt = min(a0, a1);
+
+        assert_equals(result_ct == result_rt, true, "min(3, 7): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "min(3, 7): type mismatch");
+    });
+
+    addFact("max - 2 Arg(s)", function() {
+        var result_ct = max(3, 7);
+		var a0 = 3;
+		var a1 = 7;
+        var result_rt = max(a0, a1);
+
+        assert_equals(result_ct == result_rt, true, "max(3, 7): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "max(3, 7): type mismatch");
+    });
+
+    addFact("mean - 2 Arg(s)", function() {
+        var result_ct = mean(3, 7);
+		var a0 = 3;
+		var a1 = 7;
+        var result_rt = mean(a0, a1);
+
+        assert_equals(result_ct == result_rt, true, "mean(3, 7): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "mean(3, 7): type mismatch");
+    });
+
+    addFact("median - 2 Arg(s)", function() {
+        var result_ct = median(3, 7);
+		var a0 = 3;
+		var a1 = 7;
+        var result_rt = median(a0, a1);
+
+        assert_equals(result_ct == result_rt, true, "median(3, 7): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "median(3, 7): type mismatch");
+    });
+
+    addFact("clamp - 3 Arg(s)", function() {
+        var result_ct = clamp(3, 7, 0.5);
+		var a0 = 3;
+		var a1 = 7;
+		var a2 = 0.5;
+        var result_rt = clamp(a0, a1, a2);
+
+        assert_equals(result_ct == result_rt, true, "clamp(3, 7, 0.5): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "clamp(3, 7, 0.5): type mismatch");
+    });
+
+    addFact("lerp - 3 Arg(s)", function() {
+        var result_ct = lerp(3, 7, 0.5);
+		var a0 = 3;
+		var a1 = 7;
+		var a2 = 0.5;
+        var result_rt = lerp(a0, a1, a2);
+
+        assert_equals(result_ct == result_rt, true, "lerp(3, 7, 0.5): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "lerp(3, 7, 0.5): type mismatch");
+    });
+
+    addFact("logn - 2 Arg(s)", function() {
+        var result_ct = logn(3, 7);
+		var a0 = 3;
+		var a1 = 7;
+        var result_rt = logn(a0, a1);
+
+        assert_equals(result_ct == result_rt, true, "logn(3, 7): value mismatch");
+        assert_equals(typeof(result_ct), typeof(result_rt), "logn(3, 7): type mismatch");
+    });
+#endregion
+
+}
diff --git a/projects/xUnit/scripts/BasicCompileEvalConsistencyTestSuite/BasicCompileEvalConsistencyTestSuite.yy b/projects/xUnit/scripts/BasicCompileEvalConsistencyTestSuite/BasicCompileEvalConsistencyTestSuite.yy
new file mode 100644
index 00000000..b6e4fddc
--- /dev/null
+++ b/projects/xUnit/scripts/BasicCompileEvalConsistencyTestSuite/BasicCompileEvalConsistencyTestSuite.yy
@@ -0,0 +1,13 @@
+{
+  "$GMScript":"v1",
+  "%Name":"BasicCompileEvalConsistencyTestSuite",
+  "isCompatibility":false,
+  "isDnD":false,
+  "name":"BasicCompileEvalConsistencyTestSuite",
+  "parent":{
+    "name":"TestSuites",
+    "path":"folders/Tests/TestSuites.yy",
+  },
+  "resourceType":"GMScript",
+  "resourceVersion":"2.0",
+}
\ No newline at end of file
diff --git a/projects/xUnit/sequences/Sequence1/Sequence1.yy b/projects/xUnit/sequences/Sequence1/Sequence1.yy
index 355dbfd7..1a3ebe5d 100644
--- a/projects/xUnit/sequences/Sequence1/Sequence1.yy
+++ b/projects/xUnit/sequences/Sequence1/Sequence1.yy
@@ -1,5 +1,5 @@
 {
-  "$GMSequence":"",
+  "$GMSequence":"v1",
   "%Name":"Sequence1",
   "autoRecord":true,
   "backdropHeight":768,
diff --git a/projects/xUnit/sequences/Sequence2/Sequence2.yy b/projects/xUnit/sequences/Sequence2/Sequence2.yy
index d5bf934e..75005b1c 100644
--- a/projects/xUnit/sequences/Sequence2/Sequence2.yy
+++ b/projects/xUnit/sequences/Sequence2/Sequence2.yy
@@ -1,5 +1,5 @@
 {
-  "$GMSequence":"",
+  "$GMSequence":"v1",
   "%Name":"Sequence2",
   "autoRecord":true,
   "backdropHeight":768,
diff --git a/projects/xUnit/sequences/handle_testSequence/handle_testSequence.yy b/projects/xUnit/sequences/handle_testSequence/handle_testSequence.yy
index 08330277..d256ac2a 100644
--- a/projects/xUnit/sequences/handle_testSequence/handle_testSequence.yy
+++ b/projects/xUnit/sequences/handle_testSequence/handle_testSequence.yy
@@ -1,5 +1,5 @@
 {
-  "$GMSequence":"",
+  "$GMSequence":"v1",
   "%Name":"handle_testSequence",
   "autoRecord":true,
   "backdropHeight":768,
diff --git a/projects/xUnit/sprites/handle_testSprite/handle_testSprite.yy b/projects/xUnit/sprites/handle_testSprite/handle_testSprite.yy
index 97661413..e98a25a2 100644
--- a/projects/xUnit/sprites/handle_testSprite/handle_testSprite.yy
+++ b/projects/xUnit/sprites/handle_testSprite/handle_testSprite.yy
@@ -32,7 +32,7 @@
   "resourceType":"GMSprite",
   "resourceVersion":"2.0",
   "sequence":{
-    "$GMSequence":"",
+    "$GMSequence":"v1",
     "%Name":"handle_testSprite",
     "autoRecord":true,
     "backdropHeight":768,
diff --git a/projects/xUnit/sprites/sprAlphaTest/sprAlphaTest.yy b/projects/xUnit/sprites/sprAlphaTest/sprAlphaTest.yy
index 563dae22..5d09ba26 100644
--- a/projects/xUnit/sprites/sprAlphaTest/sprAlphaTest.yy
+++ b/projects/xUnit/sprites/sprAlphaTest/sprAlphaTest.yy
@@ -32,7 +32,7 @@
   "resourceType":"GMSprite",
   "resourceVersion":"2.0",
   "sequence":{
-    "$GMSequence":"",
+    "$GMSequence":"v1",
     "%Name":"sprAlphaTest",
     "autoRecord":true,
     "backdropHeight":768,
diff --git a/projects/xUnit/sprites/sprCircle/sprCircle.yy b/projects/xUnit/sprites/sprCircle/sprCircle.yy
index 2b09cb3f..d9f72320 100644
--- a/projects/xUnit/sprites/sprCircle/sprCircle.yy
+++ b/projects/xUnit/sprites/sprCircle/sprCircle.yy
@@ -32,7 +32,7 @@
   "resourceType":"GMSprite",
   "resourceVersion":"2.0",
   "sequence":{
-    "$GMSequence":"",
+    "$GMSequence":"v1",
     "%Name":"",
     "autoRecord":true,
     "backdropHeight":1080,
diff --git a/projects/xUnit/sprites/sprSquare/sprSquare.yy b/projects/xUnit/sprites/sprSquare/sprSquare.yy
index daadf6a7..eacf39e8 100644
--- a/projects/xUnit/sprites/sprSquare/sprSquare.yy
+++ b/projects/xUnit/sprites/sprSquare/sprSquare.yy
@@ -32,7 +32,7 @@
   "resourceType":"GMSprite",
   "resourceVersion":"2.0",
   "sequence":{
-    "$GMSequence":"",
+    "$GMSequence":"v1",
     "%Name":"",
     "autoRecord":true,
     "backdropHeight":1080,
diff --git a/projects/xUnit/sprites/sprTileset/sprTileset.yy b/projects/xUnit/sprites/sprTileset/sprTileset.yy
index e1ff800a..1b017a69 100644
--- a/projects/xUnit/sprites/sprTileset/sprTileset.yy
+++ b/projects/xUnit/sprites/sprTileset/sprTileset.yy
@@ -32,7 +32,7 @@
   "resourceType":"GMSprite",
   "resourceVersion":"2.0",
   "sequence":{
-    "$GMSequence":"",
+    "$GMSequence":"v1",
     "%Name":"",
     "autoRecord":true,
     "backdropHeight":1080,
diff --git a/projects/xUnit/sprites/sprTilesetReplacement/sprTilesetReplacement.yy b/projects/xUnit/sprites/sprTilesetReplacement/sprTilesetReplacement.yy
index 961177c1..d6c9188e 100644
--- a/projects/xUnit/sprites/sprTilesetReplacement/sprTilesetReplacement.yy
+++ b/projects/xUnit/sprites/sprTilesetReplacement/sprTilesetReplacement.yy
@@ -32,7 +32,7 @@
   "resourceType":"GMSprite",
   "resourceVersion":"2.0",
   "sequence":{
-    "$GMSequence":"",
+    "$GMSequence":"v1",
     "%Name":"",
     "autoRecord":true,
     "backdropHeight":1080,
diff --git a/projects/xUnit/xUnit.yyp b/projects/xUnit/xUnit.yyp
index 67595487..3ff69f6b 100644
--- a/projects/xUnit/xUnit.yyp
+++ b/projects/xUnit/xUnit.yyp
@@ -65,7 +65,6 @@
   ],
   "ForcedPrefabProjectReferences":[],
   "IncludedFiles":[
-    {"$GMIncludedFile":"","%Name":"config.json","CopyToMask":-1,"filePath":"datafiles","name":"config.json","resourceType":"GMIncludedFile","resourceVersion":"2.0",},
     {"$GMIncludedFile":"","%Name":"drawTilemapTestExpected.png","CopyToMask":-1,"filePath":"datafiles","name":"drawTilemapTestExpected.png","resourceType":"GMIncludedFile","resourceVersion":"2.0",},
     {"$GMIncludedFile":"","%Name":"drawTilemapTestExpectedBuffer","CopyToMask":-1,"filePath":"datafiles","name":"drawTilemapTestExpectedBuffer","resourceType":"GMIncludedFile","resourceVersion":"2.0",},
     {"$GMIncludedFile":"","%Name":"drawTileTestExpected.png","CopyToMask":-1,"filePath":"datafiles","name":"drawTileTestExpected.png","resourceType":"GMIncludedFile","resourceVersion":"2.0",},
@@ -204,7 +203,7 @@
   "isEcma":false,
   "LibraryEmitters":[],
   "MetaData":{
-    "IDEVersion":"9.9.1.945",
+    "IDEVersion":"2024.1300.0.785",
   },
   "name":"xUnit",
   "resources":[
@@ -248,6 +247,7 @@
     {"id":{"name":"BasicAudioTestSuite","path":"scripts/BasicAudioTestSuite/BasicAudioTestSuite.yy",},},
     {"id":{"name":"BasicBase64TestSuite","path":"scripts/BasicBase64TestSuite/BasicBase64TestSuite.yy",},},
     {"id":{"name":"BasicBufferTestSuite","path":"scripts/BasicBufferTestSuite/BasicBufferTestSuite.yy",},},
+    {"id":{"name":"BasicCompileEvalConsistencyTestSuite","path":"scripts/BasicCompileEvalConsistencyTestSuite/BasicCompileEvalConsistencyTestSuite.yy",},},
     {"id":{"name":"BasicDataStructuresGridTestSuite","path":"scripts/BasicDataStructuresGridTestSuite/BasicDataStructuresGridTestSuite.yy",},},
     {"id":{"name":"BasicDataStructuresListTestSuite","path":"scripts/BasicDataStructuresListTestSuite/BasicDataStructuresListTestSuite.yy",},},
     {"id":{"name":"BasicDataStructuresMapTestSuite","path":"scripts/BasicDataStructuresMapTestSuite/BasicDataStructuresMapTestSuite.yy",},},