Add xpop_slot test (#476)

* add xpop_slot test

* clang-format

src/test/app/SetJSHook_test.cpp

@@ -21,6 +21,7 @@
 #include <ripple/app/tx/impl/SetHook.h>
 #include <ripple/protocol/TxFlags.h>
 #include <ripple/protocol/jss.h>
+#include <test/app/Import_json.h>
 #include <test/app/SetJSHook_wasm.h>
 #include <test/jtx.h>
 #include <test/jtx/hook.h>
@@ -5004,6 +5005,101 @@ public:
         BEAST_EXPECT(hookExecutions[1].getFieldU64(sfHookReturnCode) == 1);
     }
 
+    void
+    test_xpop_slot(FeatureBitset features)
+    {
+        testcase("Test xpop_slot");
+        using namespace jtx;
+        std::vector<std::string> const keys = {
+            "ED74D4036C6591A4BDF9C54CEFA39B996A5DCE5F86D11FDA1874481CE9D5A1CDC"
+            "1"};
+        Env env{*this, network::makeNetworkVLConfig(21337, keys)};
+
+        auto const master = Account("masterpassphrase");
+        env(noop(master), fee(10'000'000'000), ter(tesSUCCESS));
+        env.close();
+
+        Account const alice{"alice"};
+        Account const bob{"bob"};
+        env.fund(XRP(10000), alice);
+        env.fund(XRP(10000), bob);
+
+        TestHook hook = jswasm[R"[test.hook](
+            const ttIMPORT = 97
+            const DOESNT_EXIST = -5
+            const INVALID_ARGUMENT = -7
+            const ALREADY_SET = -8
+            const PREREQUISITE_NOT_MET = -9
+            const INVALID_TXN = -37
+            const ASSERT = (x) => {
+                if (!x) rollback(x.toString(), 0);
+            }
+            const sfBlob = (7 << 16) + 26
+            const sfAccount = (8 << 16) + 1
+            const sfTransactionType = (1 << 16) + 2
+            const sfHookExecutions = (15 << 16) + 18
+            const sfTransactionResult = (16 << 16) + 3
+            const sfAffectedNodes = (15 << 16) + 8
+            const sfTransactionIndex = (2 << 16) + 28
+            const Hook = (r) => {
+                // invalid tt
+                if (otxn_type() !== ttIMPORT)
+                {
+                    ASSERT(xpop_slot(1, 2) === PREREQUISITE_NOT_MET);
+                    return accept("",1);
+                }
+
+                // invalid slotno
+                ASSERT(xpop_slot(256, 1) === INVALID_ARGUMENT);
+                ASSERT(xpop_slot(1, 256) === INVALID_ARGUMENT);
+                ASSERT(xpop_slot(1, 1) === INVALID_ARGUMENT);
+
+                ASSERT(xpop_slot(1, 11) === ((1 << 16) + 11));
+
+                ASSERT(slot_subfield(1, sfTransactionType, 2) === 2);
+                ASSERT(slot_subfield(1, sfAccount, 3) === 3);
+
+                ASSERT(slot_subfield(11, sfTransactionIndex, 12) === 12);
+                ASSERT(slot_subfield(11, sfAffectedNodes, 13) === 13);
+                ASSERT(slot_subfield(11, sfTransactionResult, 14) === 14);
+
+                return accept("",2);
+            }
+        )[test.hook]"];
+
+        // install the hook on alice
+        env(ripple::test::jtx::hook(
+                alice, {{hsov1(hook, 1, HSDROPS, overrideFlag)}}, 0),
+            M("set xpop_slot"),
+            HSFEE);
+        env.close();
+
+        auto checkResult =
+            [this](auto const& meta, uint64_t expectedCode) -> void {
+            BEAST_REQUIRE(meta);
+            BEAST_REQUIRE(meta->isFieldPresent(sfHookExecutions));
+            auto const hookExecutions = meta->getFieldArray(sfHookExecutions);
+            BEAST_REQUIRE(hookExecutions.size() == 1);
+            BEAST_EXPECT(
+                hookExecutions[0].getFieldU64(sfHookReturnCode) ==
+                expectedCode);
+        };
+
+        env(pay(bob, alice, XRP(1)), M("test xpop_slot"), fee(XRP(1)));
+        env.close();
+        auto meta = env.meta();
+        checkResult(meta, 1);
+
+        // sfBlob is required and validity check is done in the Import
+        // transaction.
+
+        auto const xpopJson = import::loadXpop(ImportTCAccountSet::w_seed);
+        env(import::import(alice, xpopJson), M("test xpop_slot"), fee(XRP(1)));
+        env.close();
+        meta = env.meta();
+        checkResult(meta, 2);
+    }
+
     void
     test_otxn_id(FeatureBitset features)
     {
@@ -10408,7 +10504,7 @@ public:
         test_ledger_seq(features);        //
 
         test_meta_slot(features);  //
-        // test_xpop_slot(features);  //
+        test_xpop_slot(features);  //
 
         test_otxn_id(features);    //
         test_otxn_slot(features);  //

src/test/app/SetJSHook_wasm.h

@@ -5906,6 +5906,152 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x4fU, 0x71U, 0x71U, 0x71U, 0x72U, 0x37U, 0x72U, 0x68U}},
 
     /* ==== WASM: 34 ==== */
+    {R"[test.hook](
+            const ttIMPORT = 97
+            const DOESNT_EXIST = -5
+            const INVALID_ARGUMENT = -7
+            const ALREADY_SET = -8
+            const PREREQUISITE_NOT_MET = -9
+            const INVALID_TXN = -37
+            const ASSERT = (x) => {
+                if (!x) rollback(x.toString(), 0);
+            }
+            const sfBlob = (7 << 16) + 26
+            const sfAccount = (8 << 16) + 1
+            const sfTransactionType = (1 << 16) + 2
+            const sfHookExecutions = (15 << 16) + 18
+            const sfTransactionResult = (16 << 16) + 3
+            const sfAffectedNodes = (15 << 16) + 8
+            const sfTransactionIndex = (2 << 16) + 28
+            const Hook = (r) => {
+                // invalid tt
+                if (otxn_type() !== ttIMPORT)
+                {
+                    ASSERT(xpop_slot(1, 2) === PREREQUISITE_NOT_MET);
+                    return accept("",1);
+                }
+
+                // invalid slotno
+                ASSERT(xpop_slot(256, 1) === INVALID_ARGUMENT);
+                ASSERT(xpop_slot(1, 256) === INVALID_ARGUMENT);
+                ASSERT(xpop_slot(1, 1) === INVALID_ARGUMENT);
+
+                ASSERT(xpop_slot(1, 11) === ((1 << 16) + 11));
+
+                ASSERT(slot_subfield(1, sfTransactionType, 2) === 2);
+                ASSERT(slot_subfield(1, sfAccount, 3) === 3);
+
+                ASSERT(slot_subfield(11, sfTransactionIndex, 12) === 12);
+                ASSERT(slot_subfield(11, sfAffectedNodes, 13) === 13);
+                ASSERT(slot_subfield(11, sfTransactionResult, 14) === 14);
+
+                return accept("",2);
+            }
+        )[test.hook]",
+     {0x43U, 0x17U, 0x10U, 0x74U, 0x74U, 0x49U, 0x4dU, 0x50U, 0x4fU, 0x52U,
+      0x54U, 0x18U, 0x44U, 0x4fU, 0x45U, 0x53U, 0x4eU, 0x54U, 0x5fU, 0x45U,
+      0x58U, 0x49U, 0x53U, 0x54U, 0x20U, 0x49U, 0x4eU, 0x56U, 0x41U, 0x4cU,
+      0x49U, 0x44U, 0x5fU, 0x41U, 0x52U, 0x47U, 0x55U, 0x4dU, 0x45U, 0x4eU,
+      0x54U, 0x16U, 0x41U, 0x4cU, 0x52U, 0x45U, 0x41U, 0x44U, 0x59U, 0x5fU,
+      0x53U, 0x45U, 0x54U, 0x28U, 0x50U, 0x52U, 0x45U, 0x52U, 0x45U, 0x51U,
+      0x55U, 0x49U, 0x53U, 0x49U, 0x54U, 0x45U, 0x5fU, 0x4eU, 0x4fU, 0x54U,
+      0x5fU, 0x4dU, 0x45U, 0x54U, 0x16U, 0x49U, 0x4eU, 0x56U, 0x41U, 0x4cU,
+      0x49U, 0x44U, 0x5fU, 0x54U, 0x58U, 0x4eU, 0x0cU, 0x41U, 0x53U, 0x53U,
+      0x45U, 0x52U, 0x54U, 0x0cU, 0x73U, 0x66U, 0x42U, 0x6cU, 0x6fU, 0x62U,
+      0x12U, 0x73U, 0x66U, 0x41U, 0x63U, 0x63U, 0x6fU, 0x75U, 0x6eU, 0x74U,
+      0x22U, 0x73U, 0x66U, 0x54U, 0x72U, 0x61U, 0x6eU, 0x73U, 0x61U, 0x63U,
+      0x74U, 0x69U, 0x6fU, 0x6eU, 0x54U, 0x79U, 0x70U, 0x65U, 0x20U, 0x73U,
+      0x66U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x45U, 0x78U, 0x65U, 0x63U, 0x75U,
+      0x74U, 0x69U, 0x6fU, 0x6eU, 0x73U, 0x26U, 0x73U, 0x66U, 0x54U, 0x72U,
+      0x61U, 0x6eU, 0x73U, 0x61U, 0x63U, 0x74U, 0x69U, 0x6fU, 0x6eU, 0x52U,
+      0x65U, 0x73U, 0x75U, 0x6cU, 0x74U, 0x1eU, 0x73U, 0x66U, 0x41U, 0x66U,
+      0x66U, 0x65U, 0x63U, 0x74U, 0x65U, 0x64U, 0x4eU, 0x6fU, 0x64U, 0x65U,
+      0x73U, 0x24U, 0x73U, 0x66U, 0x54U, 0x72U, 0x61U, 0x6eU, 0x73U, 0x61U,
+      0x63U, 0x74U, 0x69U, 0x6fU, 0x6eU, 0x49U, 0x6eU, 0x64U, 0x65U, 0x78U,
+      0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U,
+      0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U,
+      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x34U, 0x2dU, 0x67U,
+      0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x10U, 0x72U, 0x6fU,
+      0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x02U, 0x72U, 0x12U, 0x6fU,
+      0x74U, 0x78U, 0x6eU, 0x5fU, 0x74U, 0x79U, 0x70U, 0x65U, 0x12U, 0x78U,
+      0x70U, 0x6fU, 0x70U, 0x5fU, 0x73U, 0x6cU, 0x6fU, 0x74U, 0x0cU, 0x61U,
+      0x63U, 0x63U, 0x65U, 0x70U, 0x74U, 0x1aU, 0x73U, 0x6cU, 0x6fU, 0x74U,
+      0x5fU, 0x73U, 0x75U, 0x62U, 0x66U, 0x69U, 0x65U, 0x6cU, 0x64U, 0x0cU,
+      0x00U, 0x06U, 0x00U, 0xa2U, 0x01U, 0x00U, 0x01U, 0x00U, 0x02U, 0x00U,
+      0x02U, 0xcdU, 0x02U, 0x01U, 0xa4U, 0x01U, 0x00U, 0x00U, 0x00U, 0x3fU,
+      0xe3U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3fU, 0xe4U, 0x00U, 0x00U, 0x00U,
+      0x80U, 0x3fU, 0xe5U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3fU, 0xe6U, 0x00U,
+      0x00U, 0x00U, 0x80U, 0x3fU, 0xe7U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3fU,
+      0xe8U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3fU, 0xe9U, 0x00U, 0x00U, 0x00U,
+      0x80U, 0x3fU, 0xeaU, 0x00U, 0x00U, 0x00U, 0x80U, 0x3fU, 0xebU, 0x00U,
+      0x00U, 0x00U, 0x80U, 0x3fU, 0xecU, 0x00U, 0x00U, 0x00U, 0x80U, 0x3fU,
+      0xedU, 0x00U, 0x00U, 0x00U, 0x80U, 0x3fU, 0xeeU, 0x00U, 0x00U, 0x00U,
+      0x80U, 0x3fU, 0xefU, 0x00U, 0x00U, 0x00U, 0x80U, 0x3fU, 0xf0U, 0x00U,
+      0x00U, 0x00U, 0x80U, 0x3fU, 0xf1U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU,
+      0xe3U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU, 0xe4U, 0x00U, 0x00U, 0x00U,
+      0x80U, 0x3eU, 0xe5U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU, 0xe6U, 0x00U,
+      0x00U, 0x00U, 0x80U, 0x3eU, 0xe7U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU,
+      0xe8U, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU, 0xe9U, 0x00U, 0x00U, 0x00U,
+      0x80U, 0x3eU, 0xeaU, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU, 0xebU, 0x00U,
+      0x00U, 0x00U, 0x80U, 0x3eU, 0xecU, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU,
+      0xedU, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU, 0xeeU, 0x00U, 0x00U, 0x00U,
+      0x80U, 0x3eU, 0xefU, 0x00U, 0x00U, 0x00U, 0x80U, 0x3eU, 0xf0U, 0x00U,
+      0x00U, 0x00U, 0x80U, 0x3eU, 0xf1U, 0x00U, 0x00U, 0x00U, 0x80U, 0xbfU,
+      0x61U, 0x3aU, 0xe3U, 0x00U, 0x00U, 0x00U, 0xbfU, 0xfbU, 0x3aU, 0xe4U,
+      0x00U, 0x00U, 0x00U, 0xbfU, 0xf9U, 0x3aU, 0xe5U, 0x00U, 0x00U, 0x00U,
+      0xbfU, 0xf8U, 0x3aU, 0xe6U, 0x00U, 0x00U, 0x00U, 0xbfU, 0xf7U, 0x3aU,
+      0xe7U, 0x00U, 0x00U, 0x00U, 0xbfU, 0xdbU, 0x3aU, 0xe8U, 0x00U, 0x00U,
+      0x00U, 0xc2U, 0x00U, 0x4dU, 0xe9U, 0x00U, 0x00U, 0x00U, 0x3aU, 0xe9U,
+      0x00U, 0x00U, 0x00U, 0xbeU, 0xbfU, 0x10U, 0xa1U, 0xbfU, 0x1aU, 0x9eU,
+      0x3aU, 0xeaU, 0x00U, 0x00U, 0x00U, 0xbfU, 0x08U, 0xbfU, 0x10U, 0xa1U,
+      0xb8U, 0x9eU, 0x3aU, 0xebU, 0x00U, 0x00U, 0x00U, 0xb8U, 0xbfU, 0x10U,
+      0xa1U, 0xb9U, 0x9eU, 0x3aU, 0xecU, 0x00U, 0x00U, 0x00U, 0xbfU, 0x0fU,
+      0xbfU, 0x10U, 0xa1U, 0xbfU, 0x12U, 0x9eU, 0x3aU, 0xedU, 0x00U, 0x00U,
+      0x00U, 0xbfU, 0x10U, 0xbfU, 0x10U, 0xa1U, 0xbaU, 0x9eU, 0x3aU, 0xeeU,
+      0x00U, 0x00U, 0x00U, 0xbfU, 0x0fU, 0xbfU, 0x10U, 0xa1U, 0xbfU, 0x08U,
+      0x9eU, 0x3aU, 0xefU, 0x00U, 0x00U, 0x00U, 0xb9U, 0xbfU, 0x10U, 0xa1U,
+      0xbfU, 0x1cU, 0x9eU, 0x3aU, 0xf0U, 0x00U, 0x00U, 0x00U, 0xc2U, 0x01U,
+      0x4dU, 0xf1U, 0x00U, 0x00U, 0x00U, 0x3aU, 0xf1U, 0x00U, 0x00U, 0x00U,
+      0xc7U, 0x28U, 0xe4U, 0x03U, 0x01U, 0x16U, 0x00U, 0x5aU, 0x01U, 0x00U,
+      0x5aU, 0x04U, 0x26U, 0x26U, 0x26U, 0x26U, 0x26U, 0x28U, 0x3fU, 0x3fU,
+      0x3fU, 0x3aU, 0x44U, 0x3fU, 0x44U, 0x00U, 0x0cU, 0x30U, 0x0cU, 0x02U,
+      0x06U, 0x00U, 0x00U, 0x01U, 0x00U, 0x01U, 0x03U, 0x00U, 0x00U, 0x16U,
+      0x01U, 0xe6U, 0x03U, 0x00U, 0x01U, 0x00U, 0xd3U, 0x97U, 0xecU, 0x12U,
+      0x38U, 0xf4U, 0x00U, 0x00U, 0x00U, 0xd3U, 0x42U, 0x38U, 0x00U, 0x00U,
+      0x00U, 0x24U, 0x00U, 0x00U, 0xb7U, 0xf2U, 0x0eU, 0x29U, 0xe4U, 0x03U,
+      0x08U, 0x02U, 0x03U, 0x6cU, 0x0cU, 0x02U, 0x06U, 0x00U, 0x00U, 0x01U,
+      0x00U, 0x01U, 0x05U, 0x00U, 0x00U, 0x89U, 0x02U, 0x01U, 0xeaU, 0x03U,
+      0x00U, 0x01U, 0x00U, 0x38U, 0xf6U, 0x00U, 0x00U, 0x00U, 0xf0U, 0x38U,
+      0xe3U, 0x00U, 0x00U, 0x00U, 0xadU, 0xecU, 0x20U, 0x38U, 0xe9U, 0x00U,
+      0x00U, 0x00U, 0x38U, 0xf7U, 0x00U, 0x00U, 0x00U, 0xb8U, 0xb9U, 0xf2U,
+      0x38U, 0xe7U, 0x00U, 0x00U, 0x00U, 0xacU, 0xf1U, 0x0eU, 0x38U, 0xf8U,
+      0x00U, 0x00U, 0x00U, 0xc3U, 0xb8U, 0x23U, 0x02U, 0x00U, 0x38U, 0xe9U,
+      0x00U, 0x00U, 0x00U, 0x38U, 0xf7U, 0x00U, 0x00U, 0x00U, 0xc0U, 0x00U,
+      0x01U, 0xb8U, 0xf2U, 0x38U, 0xe5U, 0x00U, 0x00U, 0x00U, 0xacU, 0xf1U,
+      0x0eU, 0x38U, 0xe9U, 0x00U, 0x00U, 0x00U, 0x38U, 0xf7U, 0x00U, 0x00U,
+      0x00U, 0xb8U, 0xc0U, 0x00U, 0x01U, 0xf2U, 0x38U, 0xe5U, 0x00U, 0x00U,
+      0x00U, 0xacU, 0xf1U, 0x0eU, 0x38U, 0xe9U, 0x00U, 0x00U, 0x00U, 0x38U,
+      0xf7U, 0x00U, 0x00U, 0x00U, 0xb8U, 0xb8U, 0xf2U, 0x38U, 0xe5U, 0x00U,
+      0x00U, 0x00U, 0xacU, 0xf1U, 0x0eU, 0x38U, 0xe9U, 0x00U, 0x00U, 0x00U,
+      0x38U, 0xf7U, 0x00U, 0x00U, 0x00U, 0xb8U, 0xbfU, 0x0bU, 0xf2U, 0xb8U,
+      0xbfU, 0x10U, 0xa1U, 0xbfU, 0x0bU, 0x9eU, 0xacU, 0xf1U, 0x0eU, 0x38U,
+      0xe9U, 0x00U, 0x00U, 0x00U, 0x38U, 0xf9U, 0x00U, 0x00U, 0x00U, 0xb8U,
+      0x38U, 0xecU, 0x00U, 0x00U, 0x00U, 0xb9U, 0xf3U, 0xb9U, 0xacU, 0xf1U,
+      0x0eU, 0x38U, 0xe9U, 0x00U, 0x00U, 0x00U, 0x38U, 0xf9U, 0x00U, 0x00U,
+      0x00U, 0xb8U, 0x38U, 0xebU, 0x00U, 0x00U, 0x00U, 0xbaU, 0xf3U, 0xbaU,
+      0xacU, 0xf1U, 0x0eU, 0x38U, 0xe9U, 0x00U, 0x00U, 0x00U, 0x38U, 0xf9U,
+      0x00U, 0x00U, 0x00U, 0xbfU, 0x0bU, 0x38U, 0xf0U, 0x00U, 0x00U, 0x00U,
+      0xbfU, 0x0cU, 0xf3U, 0xbfU, 0x0cU, 0xacU, 0xf1U, 0x0eU, 0x38U, 0xe9U,
+      0x00U, 0x00U, 0x00U, 0x38U, 0xf9U, 0x00U, 0x00U, 0x00U, 0xbfU, 0x0bU,
+      0x38U, 0xefU, 0x00U, 0x00U, 0x00U, 0xbfU, 0x0dU, 0xf3U, 0xbfU, 0x0dU,
+      0xacU, 0xf1U, 0x0eU, 0x38U, 0xe9U, 0x00U, 0x00U, 0x00U, 0x38U, 0xf9U,
+      0x00U, 0x00U, 0x00U, 0xbfU, 0x0bU, 0x38U, 0xeeU, 0x00U, 0x00U, 0x00U,
+      0xbfU, 0x0eU, 0xf3U, 0xbfU, 0x0eU, 0xacU, 0xf1U, 0x0eU, 0x38U, 0xf8U,
+      0x00U, 0x00U, 0x00U, 0xc3U, 0xb9U, 0x23U, 0x02U, 0x00U, 0xe4U, 0x03U,
+      0x12U, 0x0fU, 0x04U, 0x4aU, 0x6cU, 0x00U, 0x0aU, 0x08U, 0x76U, 0x76U,
+      0x6dU, 0x7cU, 0x71U, 0x72U, 0x80U, 0x80U, 0x81U}},
+
+    /* ==== WASM: 35 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -5933,7 +6079,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x13U, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x34U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x35U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U, 0x6eU,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U, 0x6fU,
       0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U,
@@ -5988,7 +6134,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x3fU, 0x2bU, 0x4eU, 0x58U, 0x2bU, 0x1cU, 0x44U, 0x44U, 0x49U, 0x49U,
       0x49U, 0x35U, 0x4eU, 0xf3U, 0x2bU}},
 
-    /* ==== WASM: 35 ==== */
+    /* ==== WASM: 36 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6025,7 +6171,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x46U, 0x52U, 0x45U, 0x45U, 0x5fU, 0x53U, 0x4cU, 0x4fU, 0x54U, 0x53U,
       0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U,
       0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U,
-      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x35U, 0x2dU, 0x67U,
+      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x36U, 0x2dU, 0x67U,
       0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U,
       0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U,
       0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U,
@@ -6095,7 +6241,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x13U, 0x3fU, 0x76U, 0x58U, 0x2bU, 0x4eU, 0x58U, 0x2bU, 0x1cU, 0x44U,
       0x44U, 0x49U, 0x49U, 0x49U, 0x35U, 0x4eU, 0xf3U, 0xdaU, 0x71U, 0x2bU}},
 
-    /* ==== WASM: 36 ==== */
+    /* ==== WASM: 37 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6120,7 +6266,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x69U, 0x6fU, 0x6eU, 0x54U, 0x79U, 0x70U, 0x65U, 0x08U, 0x48U, 0x6fU,
       0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U,
       0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U,
-      0x73U, 0x74U, 0x2dU, 0x33U, 0x36U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU,
+      0x73U, 0x74U, 0x2dU, 0x33U, 0x37U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU,
       0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U, 0x6eU, 0x65U, 0x0aU,
       0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU,
       0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U, 0x04U, 0x74U,
@@ -6158,7 +6304,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x38U, 0xf1U, 0x00U, 0x00U, 0x00U, 0xc3U, 0xb7U, 0xf2U, 0x29U, 0xccU,
       0x03U, 0x09U, 0x06U, 0x13U, 0x59U, 0x77U, 0x30U, 0x5dU, 0x2bU}},
 
-    /* ==== WASM: 37 ==== */
+    /* ==== WASM: 38 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6264,7 +6410,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x1cU, 0x37U, 0x30U, 0x36U, 0x31U, 0x37U, 0x32U, 0x36U, 0x31U, 0x36U,
       0x64U, 0x33U, 0x31U, 0x33U, 0x35U, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U,
       0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U,
-      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x37U, 0x2dU, 0x67U,
+      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x38U, 0x2dU, 0x67U,
       0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U,
       0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U,
       0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U,
@@ -6381,7 +6527,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x80U, 0x71U, 0x4eU, 0x53U, 0x53U, 0x1cU, 0x3fU, 0x3fU, 0x3fU, 0x3fU,
       0x31U, 0x0dU, 0xb2U, 0xb2U, 0x3fU, 0x2bU}},
 
-    /* ==== WASM: 38 ==== */
+    /* ==== WASM: 39 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6408,7 +6554,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x61U, 0x72U, 0x72U, 0x61U, 0x79U, 0x45U, 0x71U, 0x75U, 0x61U, 0x6cU,
       0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U,
       0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U,
-      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x38U, 0x2dU, 0x67U,
+      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x39U, 0x2dU, 0x67U,
       0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U,
       0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U,
       0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x08U, 0x61U, 0x72U,
@@ -6460,7 +6606,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x00U, 0x00U, 0x00U, 0xc3U, 0xb7U, 0xf2U, 0x29U, 0xccU, 0x03U, 0x0fU,
       0x06U, 0x12U, 0x26U, 0x5dU, 0x71U, 0xadU, 0x2bU}},
 
-    /* ==== WASM: 39 ==== */
+    /* ==== WASM: 40 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6506,7 +6652,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x4eU, 0x54U, 0x12U, 0x73U, 0x66U, 0x42U, 0x61U, 0x6cU, 0x61U, 0x6eU,
       0x63U, 0x65U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x33U, 0x39U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x30U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U,
       0x6cU, 0x69U, 0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U,
       0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U,
@@ -6594,7 +6740,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x44U, 0x35U, 0x44U, 0x80U, 0x3aU, 0x58U, 0x67U, 0x80U, 0x99U, 0x6cU,
       0x2bU}},
 
-    /* ==== WASM: 40 ==== */
+    /* ==== WASM: 41 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6617,7 +6763,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x44U, 0x4fU, 0x45U, 0x53U, 0x4eU, 0x54U, 0x5fU, 0x45U, 0x58U, 0x49U,
       0x53U, 0x54U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x30U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x31U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U,
       0x6cU, 0x69U, 0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U,
       0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U,
@@ -6659,7 +6805,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0xccU, 0x03U, 0x09U, 0x08U, 0x03U, 0x58U, 0x58U, 0x58U, 0x6cU, 0x6cU,
       0x71U, 0x2bU}},
 
-    /* ==== WASM: 41 ==== */
+    /* ==== WASM: 42 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6688,7 +6834,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x6dU, 0x6fU, 0x73U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U,
       0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U,
       0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U,
-      0x31U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U,
+      0x32U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U,
       0x08U, 0x6cU, 0x69U, 0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U,
       0x65U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU,
       0x06U, 0x61U, 0x72U, 0x67U, 0x12U, 0x6fU, 0x74U, 0x78U, 0x6eU, 0x5fU,
@@ -6736,7 +6882,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x00U, 0x00U, 0x00U, 0xc3U, 0xb7U, 0xf2U, 0x29U, 0xd0U, 0x03U, 0x0bU,
       0x09U, 0x03U, 0x58U, 0x58U, 0x6cU, 0x6cU, 0x76U, 0x58U, 0x58U, 0x2bU}},
 
-    /* ==== WASM: 42 ==== */
+    /* ==== WASM: 43 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6766,7 +6912,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x41U, 0x4dU, 0x4fU, 0x55U, 0x4eU, 0x54U, 0x0aU, 0x73U, 0x66U, 0x46U,
       0x65U, 0x65U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x32U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x33U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U,
       0x6cU, 0x69U, 0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U,
       0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U,
@@ -6821,7 +6967,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x0bU, 0x0bU, 0x12U, 0x58U, 0x58U, 0x76U, 0x58U, 0x6cU, 0x6cU, 0x2bU,
       0x44U, 0x85U, 0x2bU}},
 
-    /* ==== WASM: 43 ==== */
+    /* ==== WASM: 44 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -6891,7 +7037,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x61U, 0x33U, 0x33U, 0x06U, 0x61U, 0x33U, 0x35U, 0x06U, 0x61U, 0x33U,
       0x34U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU,
       0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U,
-      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x33U, 0x2dU,
+      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x34U, 0x2dU,
       0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU,
       0x69U, 0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U,
       0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U,
@@ -7022,7 +7168,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x7bU, 0x21U, 0x7bU, 0x71U, 0x76U, 0x5dU, 0xf3U, 0x6cU, 0x80U, 0x2bU,
       0xeeU, 0x30U, 0x53U, 0x6cU, 0x30U, 0x80U, 0x2bU}},
 
-    /* ==== WASM: 44 ==== */
+    /* ==== WASM: 45 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -7054,7 +7200,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x53U, 0x54U, 0x0aU, 0x6bU, 0x6cU, 0x5fU, 0x73U, 0x6bU, 0x08U, 0x48U,
       0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U,
       0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U,
-      0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x34U, 0x2dU, 0x67U, 0x65U, 0x6eU,
+      0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x35U, 0x2dU, 0x67U, 0x65U, 0x6eU,
       0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U, 0x6eU, 0x65U,
       0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U, 0x6fU, 0x6cU,
       0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U, 0x02U,
@@ -7115,7 +7261,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0xb7U, 0xf2U, 0x29U, 0xceU, 0x03U, 0x0eU, 0x0bU, 0x21U, 0x6cU, 0x71U,
       0x85U, 0x80U, 0x2bU, 0x44U, 0x2bU, 0x53U, 0x62U, 0x2bU}},
 
-    /* ==== WASM: 45 ==== */
+    /* ==== WASM: 46 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -7184,7 +7330,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x6cU, 0x5fU, 0x73U, 0x6bU, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU,
       0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU,
       0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU,
-      0x34U, 0x35U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U,
+      0x34U, 0x36U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U,
       0x78U, 0x08U, 0x6cU, 0x69U, 0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U,
       0x63U, 0x65U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U,
       0x6bU, 0x06U, 0x61U, 0x72U, 0x67U, 0x06U, 0x62U, 0x75U, 0x66U, 0x02U,
@@ -7299,7 +7445,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x44U, 0x44U, 0x31U, 0x0dU, 0x71U, 0x8aU, 0x44U, 0x4eU, 0x1cU, 0x3aU,
       0x44U, 0x3aU, 0x44U, 0x44U, 0x31U, 0x0dU, 0xe4U, 0x7bU, 0x2bU}},
 
-    /* ==== WASM: 46 ==== */
+    /* ==== WASM: 47 ==== */
     {R"[test.hook](
             var ASSERT = (x) => {
             if (!x) {
@@ -7361,7 +7507,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x0aU, 0x6bU, 0x6cU, 0x5fU, 0x73U, 0x6bU, 0x08U, 0x48U, 0x6fU, 0x6fU,
       0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U,
       0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U,
-      0x74U, 0x2dU, 0x34U, 0x36U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU,
+      0x74U, 0x2dU, 0x34U, 0x37U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU,
       0x73U, 0x02U, 0x78U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U,
       0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U, 0x02U, 0x69U, 0x1aU, 0x73U,
       0x6cU, 0x6fU, 0x74U, 0x5fU, 0x73U, 0x75U, 0x62U, 0x66U, 0x69U, 0x65U,
@@ -7467,7 +7613,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0xa8U, 0x85U, 0x2bU, 0x06U, 0x00U, 0x00U, 0xe0U, 0xffU, 0xffU, 0xffU,
       0xefU, 0x41U}},
 
-    /* ==== WASM: 47 ==== */
+    /* ==== WASM: 48 ==== */
     {R"[test.hook](
             var ASSERT = (x) => {
             if (!x) {
@@ -7531,7 +7677,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x6cU, 0x5fU, 0x73U, 0x6bU, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU,
       0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU,
       0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU,
-      0x34U, 0x37U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U,
+      0x34U, 0x38U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U,
       0x78U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU,
       0x06U, 0x61U, 0x72U, 0x67U, 0x0aU, 0x61U, 0x64U, 0x64U, 0x72U, 0x61U,
       0x0aU, 0x61U, 0x64U, 0x64U, 0x72U, 0x62U, 0x06U, 0x63U, 0x75U, 0x72U,
@@ -7643,7 +7789,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x53U, 0x71U, 0x6cU, 0x53U, 0x6cU, 0x71U, 0x58U, 0x6cU, 0x26U, 0x3fU,
       0x49U, 0x49U, 0x8aU, 0x76U, 0x49U, 0x62U, 0x71U, 0x58U, 0x2bU}},
 
-    /* ==== WASM: 48 ==== */
+    /* ==== WASM: 49 ==== */
     {R"[test.hook](
             var ASSERT = (x) => {
             if (!x) {
@@ -7701,7 +7847,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x74U, 0x0aU, 0x6bU, 0x6cU, 0x5fU, 0x73U, 0x6bU, 0x08U, 0x48U, 0x6fU,
       0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U,
       0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U,
-      0x73U, 0x74U, 0x2dU, 0x34U, 0x38U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU,
+      0x73U, 0x74U, 0x2dU, 0x34U, 0x39U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU,
       0x6aU, 0x73U, 0x02U, 0x78U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U,
       0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U, 0x04U, 0x6cU, 0x73U,
       0x06U, 0x74U, 0x78U, 0x73U, 0x0aU, 0x61U, 0x64U, 0x64U, 0x72U, 0x61U,
@@ -7827,7 +7973,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x0eU, 0x31U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x07U, 0x02U,
       0x30U}},
 
-    /* ==== WASM: 49 ==== */
+    /* ==== WASM: 50 ==== */
     {R"[test.hook](
                 const ASSERT = (x, code) => {
                 if (!x) {
@@ -7862,7 +8008,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x13U, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x34U, 0x39U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x30U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x63U, 0x6fU, 0x64U,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x0aU, 0x65U, 0x72U,
       0x72U, 0x6fU, 0x72U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U,
@@ -7926,7 +8072,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x53U, 0x4aU, 0x3fU, 0x53U, 0x4fU, 0x53U, 0xbcU, 0x3bU, 0x53U, 0xc6U,
       0x3bU, 0x2bU}},
 
-    /* ==== WASM: 50 ==== */
+    /* ==== WASM: 51 ==== */
     {R"[test.hook](
                 const ASSERT = (x, code) => {
                 if (!x) {
@@ -7958,7 +8104,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x10U, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x30U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x31U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x63U, 0x6fU, 0x64U,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x0aU, 0x65U, 0x72U,
       0x72U, 0x6fU, 0x72U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U,
@@ -8012,7 +8158,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x0eU, 0x21U, 0x3fU, 0x53U, 0x4aU, 0x3fU, 0x53U, 0x4fU, 0x53U, 0xbcU,
       0x3bU, 0x53U, 0xc6U, 0x3bU, 0x2bU}},
 
-    /* ==== WASM: 51 ==== */
+    /* ==== WASM: 52 ==== */
     {R"[test.hook](
                 var ASSERT = (x, code) => {
                 if (!x) {
@@ -8036,7 +8182,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x13U, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x31U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x32U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x63U, 0x6fU, 0x64U,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x0aU, 0x65U, 0x72U,
       0x72U, 0x6fU, 0x72U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U,
@@ -8085,7 +8231,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x29U, 0xcaU, 0x03U, 0x08U, 0x0bU, 0x21U, 0x85U, 0x08U, 0x49U, 0x3fU,
       0x35U, 0x08U, 0x26U, 0x4eU, 0xb2U, 0x2bU}},
 
-    /* ==== WASM: 52 ==== */
+    /* ==== WASM: 53 ==== */
     {R"[test.hook](
                 var ASSERT = (x, code) => {
                 if (!x) {
@@ -8129,7 +8275,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x44U, 0x4fU, 0x45U, 0x53U, 0x4eU, 0x54U, 0x5fU, 0x45U, 0x58U, 0x49U,
       0x53U, 0x54U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x32U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x33U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U,
       0x63U, 0x6fU, 0x64U, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U,
       0x0aU, 0x65U, 0x72U, 0x72U, 0x6fU, 0x72U, 0x10U, 0x72U, 0x6fU, 0x6cU,
@@ -8211,7 +8357,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x5dU, 0x53U, 0x49U, 0x5dU, 0x53U, 0x58U, 0x08U, 0x8aU, 0x30U, 0x0dU,
       0x71U, 0x53U, 0x4eU, 0x58U, 0xbcU, 0x3aU, 0x58U, 0xc6U, 0x3aU, 0x2bU}},
 
-    /* ==== WASM: 53 ==== */
+    /* ==== WASM: 54 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -8292,7 +8438,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x04U, 0x61U, 0x61U, 0x04U, 0x62U, 0x61U, 0x04U, 0x73U, 0x61U, 0x04U,
       0x68U, 0x61U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x33U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x34U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U,
       0x6cU, 0x69U, 0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U,
       0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U,
@@ -8571,7 +8717,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x2bU, 0x53U, 0x3fU, 0x53U, 0x08U, 0x80U, 0x30U, 0x08U, 0x08U, 0x80U,
       0x30U, 0x08U, 0x85U, 0xdaU, 0xd5U, 0x2bU}},
 
-    /* ==== WASM: 54 ==== */
+    /* ==== WASM: 55 ==== */
     {R"[test.hook](
             var ASSERT = (x, code) => {
             if (!x) {
@@ -8616,7 +8762,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x49U, 0x53U, 0x54U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U,
       0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U,
       0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U,
-      0x34U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U,
+      0x35U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U,
       0x08U, 0x63U, 0x6fU, 0x64U, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U,
       0x65U, 0x0aU, 0x65U, 0x72U, 0x72U, 0x6fU, 0x72U, 0x10U, 0x72U, 0x6fU,
       0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x08U, 0x61U, 0x72U, 0x72U,
@@ -8689,7 +8835,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x26U, 0x4eU, 0x85U, 0x08U, 0x80U, 0x30U, 0x08U, 0x08U, 0x80U, 0x30U,
       0x08U, 0x7bU, 0x53U, 0x86U, 0x2bU}},
 
-    /* ==== WASM: 55 ==== */
+    /* ==== WASM: 56 ==== */
     {R"[test.hook](
             var ASSERT = (x, code) => {
             if (!x) {
@@ -8724,7 +8870,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x73U, 0x66U, 0x49U, 0x6eU, 0x76U, 0x6fU, 0x69U, 0x63U, 0x65U, 0x49U,
       0x44U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU,
       0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U,
-      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x35U, 0x2dU,
+      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x36U, 0x2dU,
       0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x63U,
       0x6fU, 0x64U, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x0aU,
       0x65U, 0x72U, 0x72U, 0x6fU, 0x72U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU,
@@ -8792,7 +8938,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x53U, 0x3fU, 0x4eU, 0x21U, 0x53U, 0x08U, 0x80U, 0x30U, 0x08U, 0x4eU,
       0x30U, 0x53U, 0x53U, 0x53U, 0xd0U, 0x3aU, 0x2bU}},
 
-    /* ==== WASM: 56 ==== */
+    /* ==== WASM: 57 ==== */
     {R"[test.hook](
                 var ASSERT = (x, line) => {
                 if (!x) {
@@ -8852,7 +8998,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x61U, 0x04U, 0x68U, 0x61U, 0x0aU, 0x64U, 0x61U, 0x74U, 0x61U, 0x32U,
       0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U,
       0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U,
-      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x36U, 0x2dU, 0x67U,
+      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x37U, 0x2dU, 0x67U,
       0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U,
       0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U,
       0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U,
@@ -9145,7 +9291,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x03U, 0x28U, 0x0cU, 0x30U, 0x9eU, 0x9eU, 0x08U, 0x80U, 0x30U, 0x08U,
       0x53U, 0x76U, 0x26U, 0x8aU, 0x2bU}},
 
-    /* ==== WASM: 57 ==== */
+    /* ==== WASM: 58 ==== */
     {R"[test.hook](
                 var ASSERT = (x, line) => {
                 if (!x) {
@@ -9168,7 +9314,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x0dU, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x37U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x38U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U, 0x6eU,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U, 0x6fU,
       0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U,
@@ -9208,7 +9354,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x00U, 0xc3U, 0xb7U, 0xf2U, 0x29U, 0xcaU, 0x03U, 0x08U, 0x0aU, 0x30U,
       0x1cU, 0x67U, 0x7bU, 0x08U, 0x80U, 0x30U, 0x08U, 0x6cU, 0x2bU}},
 
-    /* ==== WASM: 58 ==== */
+    /* ==== WASM: 59 ==== */
     {R"[test.hook](
                 var ASSERT = (x, line) => {
                 if (!x) {
@@ -9228,7 +9374,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x0eU, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x38U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x39U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U, 0x6eU,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U, 0x6fU,
       0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U,
@@ -9268,7 +9414,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x00U, 0x00U, 0xc3U, 0xb7U, 0xf2U, 0x29U, 0xcaU, 0x03U, 0x08U, 0x07U,
       0x30U, 0x1cU, 0x67U, 0x35U, 0x53U, 0xf3U, 0x2bU}},
 
-    /* ==== WASM: 59 ==== */
+    /* ==== WASM: 60 ==== */
     {R"[test.hook](
                 var ASSERT = (x, line) => {
                 if (!x) {
@@ -9297,7 +9443,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x73U, 0x66U, 0x41U, 0x63U, 0x63U, 0x6fU, 0x75U, 0x6eU, 0x74U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x35U, 0x39U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x30U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U, 0x6eU,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U, 0x6fU,
       0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U,
@@ -9354,7 +9500,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x53U, 0x53U, 0x08U, 0x80U, 0x30U, 0x08U, 0x67U, 0x53U, 0x53U, 0xf8U,
       0x2bU}},
 
-    /* ==== WASM: 60 ==== */
+    /* ==== WASM: 61 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -9373,7 +9519,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x0dU, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x30U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x31U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU, 0x69U, 0x6eU,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U, 0x72U, 0x6fU,
       0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U,
@@ -9408,7 +9554,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x00U, 0x00U, 0xc3U, 0xb7U, 0xf2U, 0x29U, 0xcaU, 0x03U, 0x08U, 0x06U,
       0x21U, 0x26U, 0x26U, 0x71U, 0x76U, 0x2bU}},
 
-    /* ==== WASM: 61 ==== */
+    /* ==== WASM: 62 ==== */
     {R"[test.hook](
             var ASSERT = (x, line) => {
             if (!x) {
@@ -9437,7 +9583,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x73U, 0x66U, 0x49U, 0x6eU, 0x76U, 0x6fU, 0x69U, 0x63U, 0x65U, 0x49U,
       0x44U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU,
       0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U,
-      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x31U, 0x2dU,
+      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x32U, 0x2dU,
       0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x6cU,
       0x69U, 0x6eU, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x10U,
       0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U,
@@ -9491,7 +9637,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x09U, 0x0eU, 0x3fU, 0x2bU, 0x4eU, 0x3fU, 0x4eU, 0x4eU, 0x26U, 0x4eU,
       0x44U, 0x53U, 0x30U, 0x76U, 0x3aU, 0x2bU}},
 
-    /* ==== WASM: 62 ==== */
+    /* ==== WASM: 63 ==== */
     {R"[test.hook](
             const ASSERT = (x, code) => {
             if (!x) {
@@ -9509,7 +9655,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x09U, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x32U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x33U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x63U, 0x6fU, 0x64U,
       0x65U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU,
       0x06U, 0x61U, 0x72U, 0x67U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U,
@@ -9536,7 +9682,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x00U, 0x00U, 0xc3U, 0xb7U, 0xf2U, 0x29U, 0xcaU, 0x03U, 0x08U, 0x04U,
       0x03U, 0x5dU, 0x72U, 0x2bU}},
 
-    /* ==== WASM: 63 ==== */
+    /* ==== WASM: 64 ==== */
     {R"[test.hook](
             const ASSERT = (x, code) => {
             if (!x) {
@@ -10071,7 +10217,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x1fU, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x33U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x34U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x63U, 0x6fU, 0x64U,
       0x65U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU,
       0x06U, 0x61U, 0x72U, 0x67U, 0x08U, 0x61U, 0x64U, 0x64U, 0x72U, 0x02U,
@@ -10886,7 +11032,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x44U, 0x49U, 0x49U, 0x44U, 0x49U, 0x49U, 0x44U, 0x44U, 0x30U, 0x0eU,
       0x2bU}},
 
-    /* ==== WASM: 64 ==== */
+    /* ==== WASM: 65 ==== */
     {R"[test.hook](
             const ASSERT = (x, code) => {
             if (!x) {
@@ -11289,7 +11435,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x4cU, 0x49U, 0x44U, 0x5fU, 0x41U, 0x52U, 0x47U, 0x55U, 0x4dU, 0x45U,
       0x4eU, 0x54U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x34U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x35U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U,
       0x63U, 0x6fU, 0x64U, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U,
       0x0aU, 0x65U, 0x72U, 0x72U, 0x6fU, 0x72U, 0x10U, 0x72U, 0x6fU, 0x6cU,
@@ -11839,7 +11985,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x99U, 0x9eU, 0xb2U, 0x1cU, 0x46U, 0x6cU, 0x53U, 0x08U, 0x94U, 0x9eU,
       0xb7U, 0x1cU, 0x46U, 0x71U, 0x55U, 0x85U, 0x54U, 0x2bU}},
 
-    /* ==== WASM: 65 ==== */
+    /* ==== WASM: 66 ==== */
     {R"[test.hook](
             const ASSERT = (x, code) => {
             if (!x) {
@@ -12743,7 +12889,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x74U, 0x6fU, 0x48U, 0x65U, 0x78U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU,
       0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U,
       0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U,
-      0x2dU, 0x36U, 0x35U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U,
+      0x2dU, 0x36U, 0x36U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U,
       0x02U, 0x78U, 0x08U, 0x63U, 0x6fU, 0x64U, 0x65U, 0x10U, 0x72U, 0x6fU,
       0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x02U, 0x76U, 0x02U, 0x61U,
       0x02U, 0x69U, 0x08U, 0x70U, 0x75U, 0x73U, 0x68U, 0x14U, 0x63U, 0x68U,
@@ -14083,7 +14229,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x53U, 0x53U, 0x53U, 0x53U, 0x44U, 0x44U, 0x44U, 0x44U, 0x44U, 0x44U,
       0x44U, 0x44U, 0x44U, 0x30U, 0x0eU, 0x2bU}},
 
-    /* ==== WASM: 66 ==== */
+    /* ==== WASM: 67 ==== */
     {R"[test.hook](
             const ASSERT = (x, code) => {
             if (!x) {
@@ -14679,7 +14825,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
      {0x43U, 0x0cU, 0x0cU, 0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x08U,
       0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U,
       0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU,
-      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x36U, 0x2dU, 0x67U, 0x65U,
+      0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x36U, 0x37U, 0x2dU, 0x67U, 0x65U,
       0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x08U, 0x63U, 0x6fU, 0x64U,
       0x65U, 0x0aU, 0x74U, 0x72U, 0x61U, 0x63U, 0x65U, 0x0aU, 0x65U, 0x72U,
       0x72U, 0x6fU, 0x72U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U,
@@ -15508,7 +15654,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x4eU, 0x53U, 0x53U, 0x58U, 0x44U, 0x44U, 0x44U, 0x49U, 0x49U, 0x44U,
       0x44U, 0x44U, 0x30U, 0x0eU, 0x2bU}},
 
-    /* ==== WASM: 67 ==== */
+    /* ==== WASM: 68 ==== */
     {R"[test.hook](
             const ASSERT = (x, code) => {
             if (!x) {
@@ -15571,7 +15717,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x62U, 0x6dU, 0x73U, 0x67U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU,
       0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU,
       0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU,
-      0x36U, 0x37U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U,
+      0x36U, 0x38U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U,
       0x78U, 0x08U, 0x63U, 0x6fU, 0x64U, 0x65U, 0x0aU, 0x74U, 0x72U, 0x61U,
       0x63U, 0x65U, 0x0aU, 0x65U, 0x72U, 0x72U, 0x6fU, 0x72U, 0x10U, 0x72U,
       0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x06U, 0x61U, 0x72U,
@@ -15712,7 +15858,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x00U, 0x00U, 0xc3U, 0xb7U, 0xf2U, 0x29U, 0xd6U, 0x03U, 0x2bU, 0x06U,
       0x04U, 0x99U, 0x9bU, 0x99U, 0x9aU, 0x2bU}},
 
-    /* ==== WASM: 68 ==== */
+    /* ==== WASM: 69 ==== */
     {R"[test.hook](
             var ASSERT = (x) => {
               if (!x) {
@@ -15816,7 +15962,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x45U, 0x52U, 0x52U, 0x4fU, 0x52U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU,
       0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U,
       0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U,
-      0x2dU, 0x36U, 0x38U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U,
+      0x2dU, 0x36U, 0x39U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U,
       0x02U, 0x78U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U,
       0x6bU, 0x06U, 0x61U, 0x72U, 0x67U, 0x06U, 0x62U, 0x75U, 0x66U, 0x02U,
       0x69U, 0x08U, 0x73U, 0x74U, 0x6fU, 0x32U, 0x08U, 0x69U, 0x6eU, 0x73U,
@@ -16177,7 +16323,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x5dU, 0x00U, 0x36U, 0x02U, 0x00U, 0x35U, 0x02U, 0x00U, 0x3aU, 0x04U,
       0x06U, 0x00U, 0x00U, 0xe0U, 0xf5U, 0xffU, 0xffU, 0xefU, 0x41U}},
 
-    /* ==== WASM: 69 ==== */
+    /* ==== WASM: 70 ==== */
     {R"[test.hook](
             const ASSERT = (x) => {
             if (!x) rollback(x.toString(), 0)
@@ -16249,7 +16395,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x53U, 0x54U, 0x06U, 0x73U, 0x74U, 0x6fU, 0x08U, 0x48U, 0x6fU, 0x6fU,
       0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U,
       0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U,
-      0x74U, 0x2dU, 0x36U, 0x39U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU,
+      0x74U, 0x2dU, 0x37U, 0x30U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU,
       0x73U, 0x02U, 0x78U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U,
       0x63U, 0x6bU, 0x06U, 0x61U, 0x72U, 0x67U, 0x06U, 0x62U, 0x75U, 0x66U,
       0x02U, 0x69U, 0x06U, 0x72U, 0x65U, 0x70U, 0x12U, 0x73U, 0x74U, 0x6fU,
@@ -16376,7 +16522,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x08U, 0x12U, 0x5dU, 0x6dU, 0x6cU, 0x7bU, 0x00U, 0x0aU, 0x08U, 0x12U,
       0x5dU, 0x00U, 0x10U, 0x08U, 0x21U, 0x4eU, 0x53U, 0x46U, 0x3fU}},
 
-    /* ==== WASM: 70 ==== */
+    /* ==== WASM: 71 ==== */
     {R"[test.hook](
             const DOESNT_EXIST = -5
             const INVALID_ARGUMENT = -7
@@ -16421,7 +16567,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x73U, 0x74U, 0x6fU, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U,
       0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U,
       0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U,
-      0x30U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U,
+      0x31U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U,
       0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x10U,
       0x72U, 0x65U, 0x73U, 0x65U, 0x72U, 0x76U, 0x65U, 0x64U, 0x18U, 0x73U,
       0x74U, 0x6fU, 0x5fU, 0x73U, 0x75U, 0x62U, 0x61U, 0x72U, 0x72U, 0x61U,
@@ -16498,7 +16644,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x81U, 0x3fU, 0x06U, 0x00U, 0x00U, 0xe0U, 0xffU, 0xffU, 0xffU, 0xefU,
       0x41U}},
 
-    /* ==== WASM: 71 ==== */
+    /* ==== WASM: 72 ==== */
     {R"[test.hook](
             const DOESNT_EXIST = -5
             const INVALID_ARGUMENT = -7
@@ -16554,7 +16700,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x73U, 0x74U, 0x6fU, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U,
       0x65U, 0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U,
       0x6aU, 0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U,
-      0x31U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U,
+      0x32U, 0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U,
       0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x10U,
       0x72U, 0x65U, 0x73U, 0x65U, 0x72U, 0x76U, 0x65U, 0x64U, 0x18U, 0x73U,
       0x74U, 0x6fU, 0x5fU, 0x73U, 0x75U, 0x62U, 0x66U, 0x69U, 0x65U, 0x6cU,
@@ -16647,7 +16793,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x1eU, 0x08U, 0x00U, 0x20U, 0x08U, 0x00U, 0x22U, 0x08U, 0xafU, 0x95U,
       0x3fU, 0x06U, 0x00U, 0x00U, 0xe0U, 0xffU, 0xffU, 0xffU, 0xefU, 0x41U}},
 
-    /* ==== WASM: 72 ==== */
+    /* ==== WASM: 73 ==== */
     {R"[test.hook](
             const INVALID_ARGUMENT = -7
             const ASSERT = (x) => {
@@ -16696,7 +16842,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x41U, 0x53U, 0x53U, 0x45U, 0x52U, 0x54U, 0x06U, 0x73U, 0x74U, 0x6fU,
       0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU, 0x65U,
       0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U, 0x62U,
-      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x32U, 0x2dU, 0x67U,
+      0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x33U, 0x2dU, 0x67U,
       0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x10U, 0x72U, 0x6fU,
       0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x10U, 0x72U, 0x65U, 0x73U,
       0x65U, 0x72U, 0x76U, 0x65U, 0x64U, 0x18U, 0x73U, 0x74U, 0x6fU, 0x5fU,
@@ -16788,7 +16934,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x29U, 0xceU, 0x03U, 0x11U, 0x0cU, 0x04U, 0x7dU, 0x69U, 0x30U, 0x69U,
       0x32U, 0x30U, 0x69U, 0x12U, 0x35U, 0x5fU, 0x3fU}},
 
-    /* ==== WASM: 73 ==== */
+    /* ==== WASM: 74 ==== */
     {R"[test.hook](
             const INVALID_ARGUMENT = -7
             const ASSERT = (x) => {
@@ -16876,7 +17022,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x34U, 0x46U, 0x4cU, 0x39U, 0x50U, 0x48U, 0x75U, 0x65U, 0x69U, 0x0eU,
       0x41U, 0x63U, 0x63U, 0x6fU, 0x75U, 0x6eU, 0x74U, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x33U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x34U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x10U,
       0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x10U, 0x72U,
       0x65U, 0x73U, 0x65U, 0x72U, 0x76U, 0x65U, 0x64U, 0x08U, 0x6aU, 0x73U,
@@ -17005,7 +17151,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x76U, 0x7bU, 0x23U, 0x53U, 0x2bU, 0x78U, 0x30U, 0x7dU, 0x32U, 0x4eU,
       0x7cU, 0x3fU, 0x07U, 0x02U, 0x32U}},
 
-    /* ==== WASM: 74 ==== */
+    /* ==== WASM: 75 ==== */
     {R"[test.hook](
             const INVALID_ARGUMENT = -7
             const ASSERT = (x) => {
@@ -17089,7 +17235,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x46U, 0x4cU, 0x39U, 0x50U, 0x48U, 0x75U, 0x65U, 0x69U, 0x0eU, 0x41U,
       0x63U, 0x63U, 0x6fU, 0x75U, 0x6eU, 0x74U, 0x3aU, 0x67U, 0x65U, 0x6eU,
       0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U,
-      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x34U, 0x2dU,
+      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x35U, 0x2dU,
       0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x78U, 0x10U, 0x72U,
       0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU, 0x10U, 0x72U, 0x65U,
       0x73U, 0x65U, 0x72U, 0x76U, 0x65U, 0x64U, 0x14U, 0x61U, 0x63U, 0x63U,
@@ -17219,7 +17365,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x47U, 0xacU, 0x28U, 0xe6U, 0x03U, 0x2cU, 0x00U, 0x07U, 0x06U, 0x31U,
       0x32U, 0x33U}},
 
-    /* ==== WASM: 75 ==== */
+    /* ==== WASM: 76 ==== */
     {R"[test.hook](
             const Hook = (arg) => {
             return accept("0", 0);
@@ -17227,7 +17373,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
         )[test.hook]",
      {0x43U, 0x04U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x35U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x36U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x06U, 0x61U, 0x72U,
       0x67U, 0x0cU, 0x61U, 0x63U, 0x63U, 0x65U, 0x70U, 0x74U, 0x0cU, 0x00U,
       0x06U, 0x00U, 0xa2U, 0x01U, 0x00U, 0x01U, 0x00U, 0x01U, 0x00U, 0x01U,
@@ -17240,7 +17386,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0xe6U, 0x00U, 0x00U, 0x00U, 0xc1U, 0x00U, 0xb7U, 0x23U, 0x02U, 0x00U,
       0xc8U, 0x03U, 0x02U, 0x01U, 0x03U, 0x07U, 0x02U, 0x30U}},
 
-    /* ==== WASM: 76 ==== */
+    /* ==== WASM: 77 ==== */
     {R"[test.hook](
             const Hook = (arg) => {
             return rollback("0", 0);
@@ -17248,7 +17394,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
         )[test.hook]",
      {0x43U, 0x04U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x36U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x37U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x06U, 0x61U, 0x72U,
       0x67U, 0x10U, 0x72U, 0x6fU, 0x6cU, 0x6cU, 0x62U, 0x61U, 0x63U, 0x6bU,
       0x0cU, 0x00U, 0x06U, 0x00U, 0xa2U, 0x01U, 0x00U, 0x01U, 0x00U, 0x01U,
@@ -17261,7 +17407,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x00U, 0x38U, 0xe6U, 0x00U, 0x00U, 0x00U, 0xc1U, 0x00U, 0xb7U, 0x23U,
       0x02U, 0x00U, 0xc8U, 0x03U, 0x02U, 0x01U, 0x03U, 0x07U, 0x02U, 0x30U}},
 
-    /* ==== WASM: 77 ==== */
+    /* ==== WASM: 78 ==== */
     {R"[test.hook](
             const Hook = (arg) => {
             console.log("HERE");
@@ -17270,7 +17416,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
         )[test.hook]",
      {0x43U, 0x08U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x37U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x38U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x06U, 0x61U, 0x72U,
       0x67U, 0x0eU, 0x63U, 0x6fU, 0x6eU, 0x73U, 0x6fU, 0x6cU, 0x65U, 0x06U,
       0x6cU, 0x6fU, 0x67U, 0x08U, 0x48U, 0x45U, 0x52U, 0x45U, 0x0cU, 0x61U,
@@ -17287,7 +17433,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0xe9U, 0x00U, 0x00U, 0x00U, 0x38U, 0xeaU, 0x00U, 0x00U, 0x00U, 0xb7U,
       0x23U, 0x02U, 0x00U, 0xc8U, 0x03U, 0x02U, 0x02U, 0x03U, 0x62U}},
 
-    /* ==== WASM: 78 ==== */
+    /* ==== WASM: 79 ==== */
     {R"[test.hook](
             const M_REPEAT_10 = (X) => X.repeat(10);
             const M_REPEAT_100 = (X) => M_REPEAT_10(X).repeat(10);
@@ -17303,7 +17449,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x52U, 0x45U, 0x50U, 0x45U, 0x41U, 0x54U, 0x5fU, 0x31U, 0x30U, 0x30U,
       0x30U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U, 0x6eU,
       0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU, 0x73U,
-      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x38U, 0x2dU,
+      0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x39U, 0x2dU,
       0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x02U, 0x58U, 0x0cU, 0x72U,
       0x65U, 0x70U, 0x65U, 0x61U, 0x74U, 0x06U, 0x61U, 0x72U, 0x67U, 0x06U,
       0x72U, 0x65U, 0x74U, 0x84U, 0x01U, 0x61U, 0x62U, 0x63U, 0x64U, 0x65U,
@@ -17345,7 +17491,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x62U, 0x00U, 0x00U, 0xb7U, 0x23U, 0x02U, 0x00U, 0xceU, 0x03U, 0x05U,
       0x02U, 0x12U, 0x3fU}},
 
-    /* ==== WASM: 79 ==== */
+    /* ==== WASM: 80 ==== */
     {R"[test.hook](
             const Hook = (arg) => {
             const test_key = "0000000000000000000000000000000000000000000000006b657900";
@@ -17355,7 +17501,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
         )[test.hook]",
      {0x43U, 0x09U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x37U, 0x39U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x38U, 0x30U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x06U, 0x61U, 0x72U,
       0x67U, 0x10U, 0x74U, 0x65U, 0x73U, 0x74U, 0x5fU, 0x6bU, 0x65U, 0x79U,
       0x14U, 0x74U, 0x65U, 0x73U, 0x74U, 0x5fU, 0x76U, 0x61U, 0x6cU, 0x75U,
@@ -17382,7 +17528,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
       0x01U, 0x00U, 0x62U, 0x00U, 0x00U, 0xf2U, 0x23U, 0x02U, 0x00U, 0xc8U,
       0x03U, 0x02U, 0x03U, 0x21U, 0x21U, 0x21U, 0x07U, 0x02U, 0x30U}},
 
-    /* ==== WASM: 80 ==== */
+    /* ==== WASM: 81 ==== */
     {R"[test.hook](
             const Hook = (arg) => {
             return accept("0", 2);
@@ -17390,7 +17536,7 @@ std::map<std::string, std::vector<uint8_t>> jswasm = {
         )[test.hook]",
      {0x43U, 0x04U, 0x08U, 0x48U, 0x6fU, 0x6fU, 0x6bU, 0x3aU, 0x67U, 0x65U,
       0x6eU, 0x65U, 0x72U, 0x61U, 0x74U, 0x65U, 0x64U, 0x2fU, 0x71U, 0x6aU,
-      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x38U, 0x30U,
+      0x73U, 0x62U, 0x2fU, 0x74U, 0x65U, 0x73U, 0x74U, 0x2dU, 0x38U, 0x31U,
       0x2dU, 0x67U, 0x65U, 0x6eU, 0x2eU, 0x6aU, 0x73U, 0x06U, 0x61U, 0x72U,
       0x67U, 0x0cU, 0x61U, 0x63U, 0x63U, 0x65U, 0x70U, 0x74U, 0x0cU, 0x00U,
       0x06U, 0x00U, 0xa2U, 0x01U, 0x00U, 0x01U, 0x00U, 0x01U, 0x00U, 0x01U,