Attachment 414750 Details for Bug 218954 – Patch

[patch] Patch

bug-218954-20201120192329.patch (text/plain), 343.70 KB, created by Yusuke Suzuki on 2020-11-20 19:23:30 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Yusuke Suzuki

Created: 2020-11-20 19:23:30 PST

Size: 343.70 KB

patch

obsolete

>Subversion Revision: 270001
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 8510a0711980bddd9c6c4784b27172105575585c..975cea99fc3ac86a990a8694fdff90f1f3297ed9 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,113 @@
>+2020-11-20  Yusuke Suzuki  <ysuzuki@apple.com>
>+
>+        [JSC] Add wasm atomics instructions
>+        https://bugs.webkit.org/show_bug.cgi?id=218954
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * assembler/MacroAssemblerX86Common.h:
>+        (JSC::MacroAssemblerX86Common::atomicXchg8):
>+        (JSC::MacroAssemblerX86Common::atomicXchg16):
>+        (JSC::MacroAssemblerX86Common::atomicXchg32):
>+        * b3/B3Kind.h:
>+        (JSC::B3::Kind::hasTraps const):
>+        * b3/B3Width.h:
>+        (JSC::B3::bytesForWidth):
>+        * bytecode/BytecodeList.rb:
>+        * interpreter/Register.h:
>+        (JSC::Register::unboxedInt64 const):
>+        (JSC::Register::asanUnsafeUnboxedInt64 const):
>+        * llint/WebAssembly.asm:
>+        * offlineasm/arm64.rb:
>+        * offlineasm/instructions.rb:
>+        * offlineasm/x86.rb:
>+        * runtime/OptionsList.h:
>+        * wasm/WasmAirIRGenerator.cpp:
>+        (JSC::Wasm::AirIRGenerator::appendEffectful):
>+        (JSC::Wasm::accessWidth):
>+        (JSC::Wasm::resultWidth):
>+        (JSC::Wasm::sizeOfAtomicLoadOp):
>+        (JSC::Wasm::AirIRGenerator::sanitizeAtomicResult):
>+        (JSC::Wasm::AirIRGenerator::appendGeneralAtomic):
>+        (JSC::Wasm::AirIRGenerator::appendStrongCAS):
>+        (JSC::Wasm::AirIRGenerator::emitAtomicLoadOp):
>+        (JSC::Wasm::AirIRGenerator::atomicLoad):
>+        (JSC::Wasm::AirIRGenerator::emitAtomicStoreOp):
>+        (JSC::Wasm::AirIRGenerator::atomicStore):
>+        (JSC::Wasm::AirIRGenerator::emitAtomicBinaryRMWOp):
>+        (JSC::Wasm::AirIRGenerator::atomicBinaryRMW):
>+        (JSC::Wasm::AirIRGenerator::emitAtomicCompareExchange):
>+        (JSC::Wasm::AirIRGenerator::atomicCompareExchange):
>+        (JSC::Wasm::AirIRGenerator::atomicWait):
>+        (JSC::Wasm::AirIRGenerator::atomicNotify):
>+        * wasm/WasmB3IRGenerator.cpp:
>+        (JSC::Wasm::accessWidth):
>+        (JSC::Wasm::resultWidth):
>+        (JSC::Wasm::sizeOfAtomicLoadOp):
>+        (JSC::Wasm::B3IRGenerator::sanitizeAtomicResult):
>+        (JSC::Wasm::B3IRGenerator::fixupPointerPlusOffsetForAtomicOps):
>+        (JSC::Wasm::B3IRGenerator::emitAtomicLoadOp):
>+        (JSC::Wasm::B3IRGenerator::atomicLoad):
>+        (JSC::Wasm::B3IRGenerator::emitAtomicStoreOp):
>+        (JSC::Wasm::B3IRGenerator::atomicStore):
>+        (JSC::Wasm::B3IRGenerator::emitAtomicBinaryRMWOp):
>+        (JSC::Wasm::B3IRGenerator::atomicBinaryRMW):
>+        (JSC::Wasm::B3IRGenerator::emitAtomicCompareExchange):
>+        (JSC::Wasm::B3IRGenerator::atomicCompareExchange):
>+        (JSC::Wasm::B3IRGenerator::atomicWait):
>+        (JSC::Wasm::B3IRGenerator::atomicNotify):
>+        * wasm/WasmFunctionParser.h:
>+        (JSC::Wasm::FunctionParser<Context>::atomicLoad):
>+        (JSC::Wasm::FunctionParser<Context>::atomicStore):
>+        (JSC::Wasm::FunctionParser<Context>::atomicBinaryRMW):
>+        (JSC::Wasm::FunctionParser<Context>::atomicCompareExchange):
>+        (JSC::Wasm::FunctionParser<Context>::atomicWait):
>+        (JSC::Wasm::FunctionParser<Context>::atomicNotify):
>+        (JSC::Wasm::FunctionParser<Context>::parseExpression):
>+        (JSC::Wasm::FunctionParser<Context>::parseUnreachableExpression):
>+        * wasm/WasmLLIntGenerator.cpp:
>+        (JSC::Wasm::LLIntGenerator::atomicLoad):
>+        (JSC::Wasm::LLIntGenerator::atomicStore):
>+        (JSC::Wasm::LLIntGenerator::atomicBinaryRMW):
>+        (JSC::Wasm::LLIntGenerator::atomicCompareExchange):
>+        (JSC::Wasm::LLIntGenerator::atomicWait):
>+        (JSC::Wasm::LLIntGenerator::atomicNotify):
>+        * wasm/WasmMemory.h:
>+        * wasm/WasmMemoryInformation.cpp:
>+        (JSC::Wasm::MemoryInformation::MemoryInformation):
>+        * wasm/WasmMemoryInformation.h:
>+        (JSC::Wasm::MemoryInformation::isShared const):
>+        * wasm/WasmOperations.cpp:
>+        (JSC::Wasm::wait):
>+        (JSC::Wasm::JSC_DEFINE_JIT_OPERATION):
>+        * wasm/WasmOperations.h:
>+        * wasm/WasmSectionParser.cpp:
>+        (JSC::Wasm::SectionParser::parseResizableLimits):
>+        (JSC::Wasm::SectionParser::parseTableHelper):
>+        (JSC::Wasm::SectionParser::parseMemoryHelper):
>+        * wasm/WasmSectionParser.h:
>+        * wasm/WasmSlowPaths.cpp:
>+        (JSC::LLInt::WASM_SLOW_PATH_DECL):
>+        * wasm/WasmSlowPaths.h:
>+        * wasm/generateWasm.py:
>+        (isAtomic):
>+        (isAtomicLoad):
>+        (isAtomicStore):
>+        (isAtomicBinaryRMW):
>+        (memoryLog2Alignment):
>+        * wasm/generateWasmOpsHeader.py:
>+        (atomicMemoryLoadMacroizer):
>+        (atomicMemoryLoadMacroizer.modifier):
>+        (atomicMemoryStoreMacroizer):
>+        (atomicMemoryStoreMacroizer.modifier):
>+        (atomicBinaryRMWMacroizer):
>+        (atomicBinaryRMWMacroizer.modifier):
>+        (atomicMemoryLog2AlignmentGenerator):
>+        (ExtAtomicOpType):
>+        * wasm/js/JSWebAssemblyInstance.cpp:
>+        (JSC::JSWebAssemblyInstance::tryCreate):
>+        * wasm/wasm.json:
>+
> 2020-11-17  Yusuke Suzuki  <ysuzuki@apple.com>
> 
>         [JSC] Improve Wasm binary test coverage
>diff --git a/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h b/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h
>index 76ddb57694da24f4ae805b0493b42a8e642f307e..c4dbb438b30c8c35693207c608400f41f2b1335d 100644
>--- a/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h
>+++ b/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h
>@@ -3845,37 +3845,31 @@ class MacroAssemblerX86Common : public AbstractMacroAssembler<Assembler> {
>     
>     void atomicXchg8(RegisterID reg, Address address)
>     {
>-        m_assembler.lock();
>         m_assembler.xchgb_rm(reg, address.offset, address.base);
>     }
>     
>     void atomicXchg8(RegisterID reg, BaseIndex address)
>     {
>-        m_assembler.lock();
>         m_assembler.xchgb_rm(reg, address.offset, address.base, address.index, address.scale);
>     }
>     
>     void atomicXchg16(RegisterID reg, Address address)
>     {
>-        m_assembler.lock();
>         m_assembler.xchgw_rm(reg, address.offset, address.base);
>     }
>     
>     void atomicXchg16(RegisterID reg, BaseIndex address)
>     {
>-        m_assembler.lock();
>         m_assembler.xchgw_rm(reg, address.offset, address.base, address.index, address.scale);
>     }
>     
>     void atomicXchg32(RegisterID reg, Address address)
>     {
>-        m_assembler.lock();
>         m_assembler.xchgl_rm(reg, address.offset, address.base);
>     }
>     
>     void atomicXchg32(RegisterID reg, BaseIndex address)
>     {
>-        m_assembler.lock();
>         m_assembler.xchgl_rm(reg, address.offset, address.base, address.index, address.scale);
>     }
>     
>diff --git a/Source/JavaScriptCore/b3/B3Kind.h b/Source/JavaScriptCore/b3/B3Kind.h
>index 1d187104003d4eb4634c30bffa0ccced780b9bd1..692af489b73f5806d7086eed5c755edaa4bc284f 100644
>--- a/Source/JavaScriptCore/b3/B3Kind.h
>+++ b/Source/JavaScriptCore/b3/B3Kind.h
>@@ -126,6 +126,14 @@ class Kind {
>         case Store8:
>         case Store16:
>         case Store:
>+        case AtomicWeakCAS:
>+        case AtomicStrongCAS:
>+        case AtomicXchgAdd:
>+        case AtomicXchgAnd:
>+        case AtomicXchgOr:
>+        case AtomicXchgSub:
>+        case AtomicXchgXor:
>+        case AtomicXchg:
>             return true;
>         default:
>             return false;
>diff --git a/Source/JavaScriptCore/b3/B3Width.h b/Source/JavaScriptCore/b3/B3Width.h
>index 1178977c4430b6a1b46a99bd867908b6878d386b..69ab64c6b7a5af8902835bbe54bdf4cadc0ef189 100644
>--- a/Source/JavaScriptCore/b3/B3Width.h
>+++ b/Source/JavaScriptCore/b3/B3Width.h
>@@ -37,7 +37,7 @@ IGNORE_RETURN_TYPE_WARNINGS_BEGIN
> namespace JSC { namespace B3 {
> 
> enum Width : int8_t {
>-    Width8,
>+    Width8 = 0,
>     Width16,
>     Width32,
>     Width64
>@@ -111,6 +111,11 @@ inline Width widthForBytes(unsigned bytes)
>     }
> }
> 
>+inline unsigned bytesForWidth(Width width)
>+{
>+    return 1U << static_cast<unsigned>(width);
>+}
>+
> inline uint64_t mask(Width width)
> {
>     switch (width) {
>diff --git a/Source/JavaScriptCore/bytecode/BytecodeList.rb b/Source/JavaScriptCore/bytecode/BytecodeList.rb
>index 7463a321a194726790d7d452cc042b81e021cea6..dec65a7d5f3aa6d358a0835013c720fb507c738a 100644
>--- a/Source/JavaScriptCore/bytecode/BytecodeList.rb
>+++ b/Source/JavaScriptCore/bytecode/BytecodeList.rb
>@@ -1691,4 +1691,70 @@
>         offset: unsigned,
>     }
> 
>+op_group :AtomicBinaryRMW,
>+    [
>+        "add",
>+        "sub",
>+        "and",
>+        "or",
>+        "xor",
>+        "xchg",
>+    ].flat_map {|op|
>+        [
>+            "i32_atomic_rmw_#{op}",
>+            "i64_atomic_rmw_#{op}",
>+            "i32_atomic_rmw8_#{op}_u",
>+            "i32_atomic_rmw16_#{op}_u",
>+            "i64_atomic_rmw8_#{op}_u",
>+            "i64_atomic_rmw16_#{op}_u",
>+            "i64_atomic_rmw32_#{op}_u",
>+        ]
>+    }.map {|op| op.to_sym },
>+    args: {
>+        dst: VirtualRegister,
>+        pointer: VirtualRegister,
>+        offset: unsigned,
>+        value: VirtualRegister,
>+    }
>+
>+op_group :AtomicCompareExchange,
>+    [
>+        :i32_atomic_rmw_cmpxchg,
>+        :i64_atomic_rmw_cmpxchg,
>+        :i32_atomic_rmw8_cmpxchg_u,
>+        :i32_atomic_rmw16_cmpxchg_u,
>+        :i64_atomic_rmw8_cmpxchg_u,
>+        :i64_atomic_rmw16_cmpxchg_u,
>+        :i64_atomic_rmw32_cmpxchg_u,
>+    ],
>+    args: {
>+        dst: VirtualRegister,
>+        pointer: VirtualRegister,
>+        offset: unsigned,
>+        expected: VirtualRegister,
>+        value: VirtualRegister,
>+    }
>+
>+op_group :AtomicWait,
>+    [
>+        :memory_atomic_wait32,
>+        :memory_atomic_wait64,
>+    ],
>+    args: {
>+        dst: VirtualRegister,
>+        pointer: VirtualRegister,
>+        offset: unsigned,
>+        value: VirtualRegister,
>+        timeout: VirtualRegister,
>+    }
>+
>+op :memory_atomic_notify,
>+    args: {
>+        dst: VirtualRegister,
>+        pointer: VirtualRegister,
>+        offset: unsigned,
>+        count: VirtualRegister,
>+    }
>+
>+
> end_section :Wasm
>diff --git a/Source/JavaScriptCore/interpreter/Register.h b/Source/JavaScriptCore/interpreter/Register.h
>index 468289d3f84c48034c9aca537de11c5c093fbefa..90d0c7b83bebd84503f907e0dfbf36b38b30a8b9 100644
>--- a/Source/JavaScriptCore/interpreter/Register.h
>+++ b/Source/JavaScriptCore/interpreter/Register.h
>@@ -68,6 +68,8 @@ namespace JSC {
>         int64_t asanUnsafeUnboxedInt52() const;
>         int64_t unboxedStrictInt52() const;
>         int64_t asanUnsafeUnboxedStrictInt52() const;
>+        int64_t unboxedInt64() const;
>+        int64_t asanUnsafeUnboxedInt64() const;
>         bool unboxedBoolean() const;
>         double unboxedDouble() const;
>         double asanUnsafeUnboxedDouble() const;
>@@ -165,6 +167,16 @@ namespace JSC {
>         return u.integer;
>     }
> 
>+    ALWAYS_INLINE int64_t Register::unboxedInt64() const
>+    {
>+        return u.integer;
>+    }
>+
>+    SUPPRESS_ASAN ALWAYS_INLINE int64_t Register::asanUnsafeUnboxedInt64() const
>+    {
>+        return u.integer;
>+    }
>+
>     ALWAYS_INLINE bool Register::unboxedBoolean() const
>     {
>         return !!payload();
>diff --git a/Source/JavaScriptCore/llint/WebAssembly.asm b/Source/JavaScriptCore/llint/WebAssembly.asm
>index 352c80765c0065d26c79e9893cc14ac7a7fdb545..1e23f5537c1d2cc8aaf0048669a8f929ab13bcb5 100644
>--- a/Source/JavaScriptCore/llint/WebAssembly.asm
>+++ b/Source/JavaScriptCore/llint/WebAssembly.asm
>@@ -566,6 +566,9 @@ slowWasmOp(table_fill)
> slowWasmOp(table_grow)
> slowWasmOp(set_global_ref)
> slowWasmOp(set_global_ref_portable_binding)
>+slowWasmOp(memory_atomic_wait32)
>+slowWasmOp(memory_atomic_wait64)
>+slowWasmOp(memory_atomic_notify)
> 
> wasmOp(grow_memory, WasmGrowMemory, macro(ctx)
>     callWasmSlowPath(_slow_path_wasm_grow_memory)
>@@ -882,6 +885,16 @@ macro emitCheckAndPreparePointer(ctx, pointer, offset, size)
>     addp memoryBase, pointer
> end
> 
>+macro emitCheckAndPreparePointerWithAlignmentCheck(ctx, pointer, offset, size)
>+    leap size - 1[pointer, offset], t5
>+    bpb t5, boundsCheckingSize, .continuation
>+.throw:
>+    throwException(OutOfBoundsMemoryAccess)
>+.continuation:
>+    addp memoryBase, pointer
>+    btpnz pointer, (size - 1), .throw
>+end
>+
> macro wasmLoadOp(name, struct, size, fn)
>     wasmOp(name, struct, macro(ctx)
>         mloadi(ctx, m_pointer, t0)
>@@ -2142,3 +2155,224 @@ wasmOp(drop_keep, WasmDropKeep, macro(ctx)
> 
>     dispatch(ctx)
> end)
>+
>+macro wasmAtomicBinaryRMWOps(lowerCaseOpcode, upperCaseOpcode, fnb, fnh, fni, fnq)
>+    wasmOp(i32_atomic_rmw8%lowerCaseOpcode%_u, WasmI32AtomicRmw8%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadi(ctx, m_value, t0)
>+        emitCheckAndPreparePointer(ctx, t3, t1, 1)
>+        fnb(t0, [t3, t1], t2, t5)
>+        andi 0xff, t0 # FIXME: ZeroExtend8To32
>+        returni(ctx, t0)
>+    end)
>+    wasmOp(i32_atomic_rmw16%lowerCaseOpcode%_u, WasmI32AtomicRmw16%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadi(ctx, m_value, t0)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 2)
>+        fnh(t0, [t3, t1], t2, t5)
>+        andi 0xffff, t0 # FIXME: ZeroExtend16To32
>+        returni(ctx, t0)
>+    end)
>+    wasmOp(i32_atomic_rmw%lowerCaseOpcode%, WasmI32AtomicRmw%upperCaseOpcode%, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadi(ctx, m_value, t0)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 4)
>+        fni(t0, [t3, t1], t2, t5)
>+        returni(ctx, t0)
>+    end)
>+    wasmOp(i64_atomic_rmw8%lowerCaseOpcode%_u, WasmI64AtomicRmw8%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadq(ctx, m_value, t0)
>+        emitCheckAndPreparePointer(ctx, t3, t1, 1)
>+        fnb(t0, [t3, t1], t2, t5)
>+        andi 0xff, t0 # FIXME: ZeroExtend8To32
>+        returnq(ctx, t0)
>+    end)
>+    wasmOp(i64_atomic_rmw16%lowerCaseOpcode%_u, WasmI64AtomicRmw16%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadq(ctx, m_value, t0)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 2)
>+        fnh(t0, [t3, t1], t2, t5)
>+        andi 0xffff, t0 # FIXME: ZeroExtend16To32
>+        returnq(ctx, t0)
>+    end)
>+    wasmOp(i64_atomic_rmw32%lowerCaseOpcode%_u, WasmI64AtomicRmw32%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadq(ctx, m_value, t0)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 4)
>+        fni(t0, [t3, t1], t2, t5)
>+        returnq(ctx, t0)
>+    end)
>+    wasmOp(i64_atomic_rmw%lowerCaseOpcode%, WasmI64AtomicRmw%upperCaseOpcode%, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadq(ctx, m_value, t0)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 8)
>+        fnq(t0, [t3, t1], t2, t5)
>+        returnq(ctx, t0)
>+    end)
>+end
>+
>+wasmAtomicBinaryRMWOps(_add, Add,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgaddb t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgaddh t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgaddi t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgaddq t0GPR, mem end)
>+wasmAtomicBinaryRMWOps(_sub, Sub,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgsubb t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgsubh t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgsubi t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgsubq t0GPR, mem end)
>+wasmAtomicBinaryRMWOps(_xchg, Xchg,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgb t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgh t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgi t0GPR, mem end,
>+    macro(t0GPR, mem, t2GPR, t5GPR) atomicxchgq t0GPR, mem end)
>+
>+macro wasmAtomicBinaryRMWOpsWithWeakCAS(lowerCaseOpcode, upperCaseOpcode, fni, fnq)
>+    wasmAtomicBinaryRMWOps(lowerCaseOpcode, upperCaseOpcode,
>+        macro(t0GPR, mem, t2GPR, t5GPR)
>+            move t0GPR, t5GPR
>+            loadb mem, t0GPR
>+        .loop:
>+            move t0GPR, t2GPR
>+            fni(t5GPR, t2GPR)
>+            batomicweakcasb t0GPR, t2GPR, mem, .loop
>+        end,
>+        macro(t0GPR, mem, t2GPR, t5GPR)
>+            move t0GPR, t5GPR
>+            loadh mem, t0GPR
>+        .loop:
>+            move t0GPR, t2GPR
>+            fni(t5GPR, t2GPR)
>+            batomicweakcash t0GPR, t2GPR, mem, .loop
>+        end,
>+        macro(t0GPR, mem, t2GPR, t5GPR)
>+            move t0GPR, t5GPR
>+            loadi mem, t0GPR
>+        .loop:
>+            move t0GPR, t2GPR
>+            fni(t5GPR, t2GPR)
>+            batomicweakcasi t0GPR, t2GPR, mem, .loop
>+        end,
>+        macro(t0GPR, mem, t2GPR, t5GPR)
>+            move t0GPR, t5GPR
>+            loadq mem, t0GPR
>+        .loop:
>+            move t0GPR, t2GPR
>+            fnq(t5GPR, t2GPR)
>+            batomicweakcasq t0GPR, t2GPR, mem, .loop
>+        end)
>+end
>+
>+wasmAtomicBinaryRMWOpsWithWeakCAS(_and, And,
>+    macro(t5GPR, t2GPR)
>+        andi t5GPR, t2GPR
>+    end,
>+    macro(t5GPR, t2GPR)
>+        andq t5GPR, t2GPR
>+    end)
>+wasmAtomicBinaryRMWOpsWithWeakCAS(_or, Or,
>+    macro(t5GPR, t2GPR)
>+        ori t5GPR, t2GPR
>+    end,
>+    macro(t5GPR, t2GPR)
>+        orq t5GPR, t2GPR
>+    end)
>+wasmAtomicBinaryRMWOpsWithWeakCAS(_xor, Xor,
>+    macro(t5GPR, t2GPR)
>+        xori t5GPR, t2GPR
>+    end,
>+    macro(t5GPR, t2GPR)
>+        xorq t5GPR, t2GPR
>+    end)
>+
>+
>+macro wasmAtomicCompareExchangeOps(lowerCaseOpcode, upperCaseOpcode, fnb, fnh, fni, fnq)
>+    wasmOp(i32_atomic_rmw8%lowerCaseOpcode%_u, WasmI32AtomicRmw8%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadi(ctx, m_expected, t0)
>+        mloadi(ctx, m_value, t2)
>+        emitCheckAndPreparePointer(ctx, t3, t1, 1)
>+        fnb(t0, t2, [t3, t1], t5)
>+        andi 0xff, t0 # FIXME: ZeroExtend8To32
>+        returni(ctx, t0)
>+    end)
>+    wasmOp(i32_atomic_rmw16%lowerCaseOpcode%_u, WasmI32AtomicRmw16%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadi(ctx, m_expected, t0)
>+        mloadi(ctx, m_value, t2)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 2)
>+        fnh(t0, t2, [t3, t1], t5)
>+        andi 0xffff, t0 # FIXME: ZeroExtend16To32
>+        returni(ctx, t0)
>+    end)
>+    wasmOp(i32_atomic_rmw%lowerCaseOpcode%, WasmI32AtomicRmw%upperCaseOpcode%, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadi(ctx, m_expected, t0)
>+        mloadi(ctx, m_value, t2)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 4)
>+        fni(t0, t2, [t3, t1], t5)
>+        returni(ctx, t0)
>+    end)
>+    wasmOp(i64_atomic_rmw8%lowerCaseOpcode%_u, WasmI64AtomicRmw8%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadq(ctx, m_expected, t0)
>+        mloadq(ctx, m_value, t2)
>+        emitCheckAndPreparePointer(ctx, t3, t1, 1)
>+        fnb(t0, t2, [t3, t1], t5)
>+        andi 0xff, t0 # FIXME: ZeroExtend8To32
>+        returnq(ctx, t0)
>+    end)
>+    wasmOp(i64_atomic_rmw16%lowerCaseOpcode%_u, WasmI64AtomicRmw16%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadq(ctx, m_expected, t0)
>+        mloadq(ctx, m_value, t2)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 2)
>+        fnh(t0, t2, [t3, t1], t5)
>+        andi 0xffff, t0 # FIXME: ZeroExtend16To32
>+        returnq(ctx, t0)
>+    end)
>+    wasmOp(i64_atomic_rmw32%lowerCaseOpcode%_u, WasmI64AtomicRmw32%upperCaseOpcode%U, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadq(ctx, m_expected, t0)
>+        mloadq(ctx, m_value, t2)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 4)
>+        fni(t0, t2, [t3, t1], t5)
>+        returnq(ctx, t0)
>+    end)
>+    wasmOp(i64_atomic_rmw%lowerCaseOpcode%, WasmI64AtomicRmw%upperCaseOpcode%, macro(ctx)
>+        mloadi(ctx, m_pointer, t3)
>+        wgetu(ctx, m_offset, t1)
>+        mloadq(ctx, m_expected, t0)
>+        mloadq(ctx, m_value, t2)
>+        emitCheckAndPreparePointerWithAlignmentCheck(ctx, t3, t1, 8)
>+        fnq(t0, t2, [t3, t1], t5)
>+        returnq(ctx, t0)
>+    end)
>+end
>+wasmAtomicCompareExchangeOps(_cmpxchg, Cmpxchg,
>+    macro(t0GPR, t2GPR, mem, t5GPR)
>+        atomicweakcasb t0GPR, t2GPR, mem
>+    end,
>+    macro(t0GPR, t2GPR, mem, t5GPR)
>+        atomicweakcash t0GPR, t2GPR, mem
>+    end,
>+    macro(t0GPR, t2GPR, mem, t5GPR)
>+        atomicweakcasi t0GPR, t2GPR, mem
>+    end,
>+    macro(t0GPR, t2GPR, mem, t5GPR)
>+        atomicweakcasq t0GPR, t2GPR, mem
>+    end)
>diff --git a/Source/JavaScriptCore/offlineasm/arm64.rb b/Source/JavaScriptCore/offlineasm/arm64.rb
>index d0fd708616b21948e8d1468c55f18b0d934e2d50..3c2d2d87db586736e92e15538e7c03b6e5b7d780 100644
>--- a/Source/JavaScriptCore/offlineasm/arm64.rb
>+++ b/Source/JavaScriptCore/offlineasm/arm64.rb
>@@ -1309,6 +1309,14 @@ def lowerARM64
>             $asm.puts "mrs #{tmp}, tpidrro_el0"
>             $asm.puts "bic #{tmp}, #{tmp}, #7"
>             $asm.puts "str #{operands[0].arm64Operand(:ptr)}, [#{tmp}, #{offset}]"
>+        when "loadlinkb"
>+            emitARM64Access("ldaxrb", "ldaxrb", operands[1], operands[0], :word)
>+        when "loadlinkh"
>+            emitARM64Access("ldaxrh", "ldaxrh", operands[1], operands[0], :word)
>+        when "loadlinki"
>+            emitARM64Access("ldaxr", "ldaxr", operands[1], operands[0], :word)
>+        when "loadlinkq"
>+            emitARM64Access("ldaxr", "ldaxr", operands[1], operands[0], :quad)
>         else
>             lowerDefault
>         end
>diff --git a/Source/JavaScriptCore/offlineasm/instructions.rb b/Source/JavaScriptCore/offlineasm/instructions.rb
>index 34f5c97b51ffe9b4806823242608a98599187c09..243cf6c6efd0e2758ac71b9cadaafbcaa2b79782 100644
>--- a/Source/JavaScriptCore/offlineasm/instructions.rb
>+++ b/Source/JavaScriptCore/offlineasm/instructions.rb
>@@ -344,6 +344,26 @@
>      "cqoq",
>      "idivq",
>      "udivq",
>+     "atomicxchgaddb",
>+     "atomicxchgaddh",
>+     "atomicxchgaddi",
>+     "atomicxchgaddq",
>+     "atomicxchgsubb",
>+     "atomicxchgsubh",
>+     "atomicxchgsubi",
>+     "atomicxchgsubq",
>+     "atomicxchgb",
>+     "atomicxchgh",
>+     "atomicxchgi",
>+     "atomicxchgq",
>+     "batomicweakcasb",
>+     "batomicweakcash",
>+     "batomicweakcasi",
>+     "batomicweakcasq",
>+     "atomicweakcasb",
>+     "atomicweakcash",
>+     "atomicweakcasi",
>+     "atomicweakcasq",
>     ]
> 
> ARM_INSTRUCTIONS =
>diff --git a/Source/JavaScriptCore/offlineasm/x86.rb b/Source/JavaScriptCore/offlineasm/x86.rb
>index 98e67e7311353236f4a9c6a38d9b5fb5a1e25d1f..0bc41200ad5528846f0dfb0837efc2ed19cab991 100644
>--- a/Source/JavaScriptCore/offlineasm/x86.rb
>+++ b/Source/JavaScriptCore/offlineasm/x86.rb
>@@ -1839,6 +1839,78 @@ def lowerX86Common
>                 mem = BaseIndex.new(codeOrigin, nil, operands[1], x86Bytes(:ptr), "%gs:").x86AddressOperand(:ptr)
>             end
>             $asm.puts "mov#{x86Suffix(:ptr)} #{orderOperands(operands[0].x86Operand(:ptr), mem)}"
>+        when "atomicxchgaddb"
>+            $asm.puts "lock"
>+            $asm.puts "xadd#{x86Suffix(:byte)} #{x86Operands(:byte, :byte)}"
>+        when "atomicxchgaddh"
>+            $asm.puts "lock"
>+            $asm.puts "xadd#{x86Suffix(:half)} #{x86Operands(:half, :half)}"
>+        when "atomicxchgaddi"
>+            $asm.puts "lock"
>+            $asm.puts "xadd#{x86Suffix(:int)} #{x86Operands(:int, :int)}"
>+        when "atomicxchgaddq"
>+            $asm.puts "lock"
>+            $asm.puts "xadd#{x86Suffix(:quad)} #{x86Operands(:quad, :quad)}"
>+        when "atomicxchgsubb"
>+            $asm.puts "neg#{x86Suffix(:byte)} #{operands[0].x86Operand(:byte)}"
>+            $asm.puts "lock"
>+            $asm.puts "xadd#{x86Suffix(:byte)} #{x86Operands(:byte, :byte)}"
>+        when "atomicxchgsubh"
>+            $asm.puts "neg#{x86Suffix(:half)} #{operands[0].x86Operand(:half)}"
>+            $asm.puts "lock"
>+            $asm.puts "xadd#{x86Suffix(:half)} #{x86Operands(:half, :half)}"
>+        when "atomicxchgsubi"
>+            $asm.puts "neg#{x86Suffix(:int)} #{operands[0].x86Operand(:int)}"
>+            $asm.puts "lock"
>+            $asm.puts "xadd#{x86Suffix(:int)} #{x86Operands(:int, :int)}"
>+        when "atomicxchgsubq"
>+            $asm.puts "neg#{x86Suffix(:quad)} #{operands[0].x86Operand(:quad)}"
>+            $asm.puts "lock"
>+            $asm.puts "xadd#{x86Suffix(:quad)} #{x86Operands(:quad, :quad)}"
>+        when "atomicxchgb"
>+            $asm.puts "xchg#{x86Suffix(:byte)} #{x86Operands(:byte, :byte)}"
>+        when "atomicxchgh"
>+            $asm.puts "xchg#{x86Suffix(:half)} #{x86Operands(:half, :half)}"
>+        when "atomicxchgi"
>+            $asm.puts "xchg#{x86Suffix(:int)} #{x86Operands(:int, :int)}"
>+        when "atomicxchgq"
>+            $asm.puts "xchg#{x86Suffix(:quad)} #{x86Operands(:quad, :quad)}"
>+        when "batomicweakcasb"
>+            raise "first operand must be t0" unless operands[0].is_a? RegisterID and operands[0].name == 't0'
>+            $asm.puts "lock"
>+            $asm.puts "cmpxchg#{x86Suffix(:byte)} #{orderOperands(operands[1].x86Operand(:byte), operands[2].x86Operand(:byte))}"
>+            $asm.puts "jne #{operands.last.asmLabel}"
>+        when "batomicweakcash"
>+            raise "first operand must be t0" unless operands[0].is_a? RegisterID and operands[0].name == 't0'
>+            $asm.puts "lock"
>+            $asm.puts "cmpxchg#{x86Suffix(:half)} #{orderOperands(operands[1].x86Operand(:half), operands[2].x86Operand(:half))}"
>+            $asm.puts "jne #{operands.last.asmLabel}"
>+        when "batomicweakcasi"
>+            raise "first operand must be t0" unless operands[0].is_a? RegisterID and operands[0].name == 't0'
>+            $asm.puts "lock"
>+            $asm.puts "cmpxchg#{x86Suffix(:int)} #{orderOperands(operands[1].x86Operand(:int), operands[2].x86Operand(:int))}"
>+            $asm.puts "jne #{operands.last.asmLabel}"
>+        when "batomicweakcasq"
>+            raise "first operand must be t0" unless operands[0].is_a? RegisterID and operands[0].name == 't0'
>+            $asm.puts "lock"
>+            $asm.puts "cmpxchg#{x86Suffix(:quad)} #{orderOperands(operands[1].x86Operand(:quad), operands[2].x86Operand(:quad))}"
>+            $asm.puts "jne #{operands.last.asmLabel}"
>+        when "atomicweakcasb"
>+            raise "first operand must be t0" unless operands[0].is_a? RegisterID and operands[0].name == 't0'
>+            $asm.puts "lock"
>+            $asm.puts "cmpxchg#{x86Suffix(:byte)} #{orderOperands(operands[1].x86Operand(:byte), operands[2].x86Operand(:byte))}"
>+        when "atomicweakcash"
>+            raise "first operand must be t0" unless operands[0].is_a? RegisterID and operands[0].name == 't0'
>+            $asm.puts "lock"
>+            $asm.puts "cmpxchg#{x86Suffix(:half)} #{orderOperands(operands[1].x86Operand(:half), operands[2].x86Operand(:half))}"
>+        when "atomicweakcasi"
>+            raise "first operand must be t0" unless operands[0].is_a? RegisterID and operands[0].name == 't0'
>+            $asm.puts "lock"
>+            $asm.puts "cmpxchg#{x86Suffix(:int)} #{orderOperands(operands[1].x86Operand(:int), operands[2].x86Operand(:int))}"
>+        when "atomicweakcasq"
>+            raise "first operand must be t0" unless operands[0].is_a? RegisterID and operands[0].name == 't0'
>+            $asm.puts "lock"
>+            $asm.puts "cmpxchg#{x86Suffix(:quad)} #{orderOperands(operands[1].x86Operand(:quad), operands[2].x86Operand(:quad))}"
>         else
>             lowerDefault
>         end
>diff --git a/Source/JavaScriptCore/runtime/OptionsList.h b/Source/JavaScriptCore/runtime/OptionsList.h
>index 3228b6c071cdc158dd559fcdec6c98dad3409b9f..254f58560f53290b409e3065851d9e3d7b9b6497 100644
>--- a/Source/JavaScriptCore/runtime/OptionsList.h
>+++ b/Source/JavaScriptCore/runtime/OptionsList.h
>@@ -491,6 +491,7 @@ JS_EXPORT_PRIVATE bool canUseJITCage();
>     v(Bool, useEagerWebAssemblyModuleHashing, false, Normal, "Unnamed WebAssembly modules are identified in backtraces through their hash, if available.") \
>     v(Bool, useWebAssemblyReferences, false, Normal, "Allow types from the wasm references spec.") \
>     v(Bool, useWebAssemblyMultiValues, true, Normal, "Allow types from the wasm mulit-values spec.") \
>+    v(Bool, useWebAssemblyThreading, true, Normal, "Allow types from the wasm threading spec.") \
>     v(Bool, useWeakRefs, true, Normal, "Expose the WeakRef constructor.") \
>     v(Bool, useIntlDateTimeFormatDayPeriod, true, Normal, "Expose the Intl.DateTimeFormat dayPeriod feature.") \
>     v(Bool, useIntlDateTimeFormatRangeToParts, true, Normal, "Expose the Intl.DateTimeFormat#formatRangeToParts feature.") \
>diff --git a/Source/JavaScriptCore/wasm/WasmAirIRGenerator.cpp b/Source/JavaScriptCore/wasm/WasmAirIRGenerator.cpp
>index e8f4cbd71100a23b86894937ded4d1cee463f9a3..b7c6d6a0e1459129fc6173c0668b62771b3b18ba 100644
>--- a/Source/JavaScriptCore/wasm/WasmAirIRGenerator.cpp
>+++ b/Source/JavaScriptCore/wasm/WasmAirIRGenerator.cpp
>@@ -35,6 +35,7 @@
> #include "AllowMacroScratchRegisterUsageIf.h"
> #include "B3CheckSpecial.h"
> #include "B3CheckValue.h"
>+#include "B3Commutativity.h"
> #include "B3PatchpointSpecial.h"
> #include "B3Procedure.h"
> #include "B3ProcedureInlines.h"
>@@ -277,6 +278,14 @@ class AirIRGenerator {
>     PartialResult WARN_UNUSED_RETURN addGrowMemory(ExpressionType delta, ExpressionType& result);
>     PartialResult WARN_UNUSED_RETURN addCurrentMemory(ExpressionType& result);
> 
>+    // Atomics
>+    PartialResult WARN_UNUSED_RETURN atomicLoad(ExtAtomicOpType, ExpressionType pointer, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicStore(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicBinaryRMW(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicCompareExchange(ExtAtomicOpType, ExpressionType pointer, ExpressionType expected, ExpressionType value, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicWait(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType timeout, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicNotify(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset);
>+
>     // Basic operators
>     template<OpType>
>     PartialResult WARN_UNUSED_RETURN addOp(ExpressionType arg, ExpressionType& result);
>@@ -362,6 +371,14 @@ class AirIRGenerator {
>         append(m_currentBlock, kind, std::forward<Arguments>(arguments)...);
>     }
> 
>+    template<typename... Arguments>
>+    void appendEffectful(BasicBlock* block, B3::Air::Opcode op, Arguments&&... arguments)
>+    {
>+        Kind kind = op;
>+        kind.effects = true;
>+        append(block, kind, std::forward<Arguments>(arguments)...);
>+    }
>+
>     Tmp newTmp(B3::Bank bank)
>     {
>         switch (bank) {
>@@ -637,6 +654,14 @@ class AirIRGenerator {
>     ExpressionType emitCheckAndPreparePointer(ExpressionType pointer, uint32_t offset, uint32_t sizeOfOp);
>     ExpressionType emitLoadOp(LoadOpType, ExpressionType pointer, uint32_t offset);
>     void emitStoreOp(StoreOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
>+    ExpressionType emitAtomicLoadOp(ExtAtomicOpType, ExpressionType pointer, uint32_t offset);
>+    void emitAtomicStoreOp(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
>+    ExpressionType emitAtomicBinaryRMWOp(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
>+    ExpressionType emitAtomicCompareExchange(ExtAtomicOpType, ExpressionType pointer, ExpressionType expected, ExpressionType value, uint32_t offset);
>+
>+    TypedTmp sanitizeAtomicResult(ExtAtomicOpType, TypedTmp result);
>+    TypedTmp appendGeneralAtomic(ExtAtomicOpType, B3::Air::Opcode nonAtomicOpcode, B3::Commutativity, Arg input, Arg addrArg);
>+    TypedTmp appendStrongCAS(ExtAtomicOpType, TypedTmp expected, TypedTmp value, Arg addrArg);
> 
>     void unify(const ExpressionType dst, const ExpressionType source);
>     void unifyValuesWithBlock(const Stack& resultStack, const ResultList& stack);
>@@ -1683,6 +1708,800 @@ auto AirIRGenerator::store(StoreOpType op, ExpressionType pointer, ExpressionTyp
>     return { };
> }
> 
>+#define OPCODE_FOR_WIDTH(opcode, width) ( \
>+    (width) == B3::Width8 ? B3::Air::opcode ## 8 : \
>+    (width) == B3::Width16 ? B3::Air::opcode ## 16 :    \
>+    (width) == B3::Width32 ? B3::Air::opcode ## 32 :    \
>+    B3::Air::opcode ## 64)
>+#define OPCODE_FOR_CANONICAL_WIDTH(opcode, width) ( \
>+    (width) == B3::Width64 ? B3::Air::opcode ## 64 : B3::Air::opcode ## 32)
>+
>+inline B3::Width accessWidth(ExtAtomicOpType op)
>+{
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicLoad8U:
>+    case ExtAtomicOpType::I32AtomicStore8U:
>+    case ExtAtomicOpType::I32AtomicRmw8AddU:
>+    case ExtAtomicOpType::I32AtomicRmw8SubU:
>+    case ExtAtomicOpType::I32AtomicRmw8AndU:
>+    case ExtAtomicOpType::I32AtomicRmw8OrU:
>+    case ExtAtomicOpType::I32AtomicRmw8XorU:
>+    case ExtAtomicOpType::I32AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I32AtomicRmw8CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicLoad8U:
>+    case ExtAtomicOpType::I64AtomicStore8U:
>+    case ExtAtomicOpType::I64AtomicRmw8AddU:
>+    case ExtAtomicOpType::I64AtomicRmw8SubU:
>+    case ExtAtomicOpType::I64AtomicRmw8AndU:
>+    case ExtAtomicOpType::I64AtomicRmw8OrU:
>+    case ExtAtomicOpType::I64AtomicRmw8XorU:
>+    case ExtAtomicOpType::I64AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw8CmpxchgU:
>+        return B3::Width8;
>+    case ExtAtomicOpType::I32AtomicLoad16U:
>+    case ExtAtomicOpType::I32AtomicStore16U:
>+    case ExtAtomicOpType::I32AtomicRmw16AddU:
>+    case ExtAtomicOpType::I32AtomicRmw16SubU:
>+    case ExtAtomicOpType::I32AtomicRmw16AndU:
>+    case ExtAtomicOpType::I32AtomicRmw16OrU:
>+    case ExtAtomicOpType::I32AtomicRmw16XorU:
>+    case ExtAtomicOpType::I32AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I32AtomicRmw16CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicLoad16U:
>+    case ExtAtomicOpType::I64AtomicStore16U:
>+    case ExtAtomicOpType::I64AtomicRmw16AddU:
>+    case ExtAtomicOpType::I64AtomicRmw16SubU:
>+    case ExtAtomicOpType::I64AtomicRmw16AndU:
>+    case ExtAtomicOpType::I64AtomicRmw16OrU:
>+    case ExtAtomicOpType::I64AtomicRmw16XorU:
>+    case ExtAtomicOpType::I64AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw16CmpxchgU:
>+        return B3::Width16;
>+    case ExtAtomicOpType::I32AtomicLoad:
>+    case ExtAtomicOpType::I32AtomicStore:
>+    case ExtAtomicOpType::I32AtomicRmwAdd:
>+    case ExtAtomicOpType::I32AtomicRmwSub:
>+    case ExtAtomicOpType::I32AtomicRmwAnd:
>+    case ExtAtomicOpType::I32AtomicRmwOr:
>+    case ExtAtomicOpType::I32AtomicRmwXor:
>+    case ExtAtomicOpType::I32AtomicRmwXchg:
>+    case ExtAtomicOpType::I32AtomicRmwCmpxchg:
>+    case ExtAtomicOpType::I64AtomicLoad32U:
>+    case ExtAtomicOpType::I64AtomicStore32U:
>+    case ExtAtomicOpType::I64AtomicRmw32AddU:
>+    case ExtAtomicOpType::I64AtomicRmw32SubU:
>+    case ExtAtomicOpType::I64AtomicRmw32AndU:
>+    case ExtAtomicOpType::I64AtomicRmw32OrU:
>+    case ExtAtomicOpType::I64AtomicRmw32XorU:
>+    case ExtAtomicOpType::I64AtomicRmw32XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw32CmpxchgU:
>+        return B3::Width32;
>+    case ExtAtomicOpType::I64AtomicLoad:
>+    case ExtAtomicOpType::I64AtomicStore:
>+    case ExtAtomicOpType::I64AtomicRmwAdd:
>+    case ExtAtomicOpType::I64AtomicRmwSub:
>+    case ExtAtomicOpType::I64AtomicRmwAnd:
>+    case ExtAtomicOpType::I64AtomicRmwOr:
>+    case ExtAtomicOpType::I64AtomicRmwXor:
>+    case ExtAtomicOpType::I64AtomicRmwXchg:
>+    case ExtAtomicOpType::I64AtomicRmwCmpxchg:
>+        return B3::Width64;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        return B3::Width8;
>+    }
>+}
>+
>+inline B3::Width resultWidth(ExtAtomicOpType op)
>+{
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicLoad8U:
>+    case ExtAtomicOpType::I32AtomicLoad16U:
>+    case ExtAtomicOpType::I32AtomicLoad:
>+    case ExtAtomicOpType::I32AtomicStore8U:
>+    case ExtAtomicOpType::I32AtomicStore16U:
>+    case ExtAtomicOpType::I32AtomicStore:
>+    case ExtAtomicOpType::I32AtomicRmw8AddU:
>+    case ExtAtomicOpType::I32AtomicRmw16AddU:
>+    case ExtAtomicOpType::I32AtomicRmwAdd:
>+    case ExtAtomicOpType::I32AtomicRmw8SubU:
>+    case ExtAtomicOpType::I32AtomicRmw16SubU:
>+    case ExtAtomicOpType::I32AtomicRmwSub:
>+    case ExtAtomicOpType::I32AtomicRmw8AndU:
>+    case ExtAtomicOpType::I32AtomicRmw16AndU:
>+    case ExtAtomicOpType::I32AtomicRmwAnd:
>+    case ExtAtomicOpType::I32AtomicRmw8OrU:
>+    case ExtAtomicOpType::I32AtomicRmw16OrU:
>+    case ExtAtomicOpType::I32AtomicRmwOr:
>+    case ExtAtomicOpType::I32AtomicRmw8XorU:
>+    case ExtAtomicOpType::I32AtomicRmw16XorU:
>+    case ExtAtomicOpType::I32AtomicRmwXor:
>+    case ExtAtomicOpType::I32AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I32AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I32AtomicRmwXchg:
>+    case ExtAtomicOpType::I32AtomicRmw8CmpxchgU:
>+    case ExtAtomicOpType::I32AtomicRmw16CmpxchgU:
>+    case ExtAtomicOpType::I32AtomicRmwCmpxchg:
>+        return B3::Width32;
>+    case ExtAtomicOpType::I64AtomicLoad8U:
>+    case ExtAtomicOpType::I64AtomicLoad16U:
>+    case ExtAtomicOpType::I64AtomicLoad32U:
>+    case ExtAtomicOpType::I64AtomicLoad:
>+    case ExtAtomicOpType::I64AtomicStore8U:
>+    case ExtAtomicOpType::I64AtomicStore16U:
>+    case ExtAtomicOpType::I64AtomicStore32U:
>+    case ExtAtomicOpType::I64AtomicStore:
>+    case ExtAtomicOpType::I64AtomicRmw8AddU:
>+    case ExtAtomicOpType::I64AtomicRmw16AddU:
>+    case ExtAtomicOpType::I64AtomicRmw32AddU:
>+    case ExtAtomicOpType::I64AtomicRmwAdd:
>+    case ExtAtomicOpType::I64AtomicRmw8SubU:
>+    case ExtAtomicOpType::I64AtomicRmw16SubU:
>+    case ExtAtomicOpType::I64AtomicRmw32SubU:
>+    case ExtAtomicOpType::I64AtomicRmwSub:
>+    case ExtAtomicOpType::I64AtomicRmw8AndU:
>+    case ExtAtomicOpType::I64AtomicRmw16AndU:
>+    case ExtAtomicOpType::I64AtomicRmw32AndU:
>+    case ExtAtomicOpType::I64AtomicRmwAnd:
>+    case ExtAtomicOpType::I64AtomicRmw8OrU:
>+    case ExtAtomicOpType::I64AtomicRmw16OrU:
>+    case ExtAtomicOpType::I64AtomicRmw32OrU:
>+    case ExtAtomicOpType::I64AtomicRmwOr:
>+    case ExtAtomicOpType::I64AtomicRmw8XorU:
>+    case ExtAtomicOpType::I64AtomicRmw16XorU:
>+    case ExtAtomicOpType::I64AtomicRmw32XorU:
>+    case ExtAtomicOpType::I64AtomicRmwXor:
>+    case ExtAtomicOpType::I64AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw32XchgU:
>+    case ExtAtomicOpType::I64AtomicRmwXchg:
>+    case ExtAtomicOpType::I64AtomicRmw8CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicRmw16CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicRmw32CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicRmwCmpxchg:
>+        return B3::Width64;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        return B3::Width8;
>+    }
>+}
>+
>+inline uint32_t sizeOfAtomicLoadOp(ExtAtomicOpType op)
>+{
>+    return bytesForWidth(accessWidth(op));
>+}
>+
>+TypedTmp AirIRGenerator::sanitizeAtomicResult(ExtAtomicOpType op, TypedTmp result)
>+{
>+    auto sanitize32 = [&]() {
>+        switch (accessWidth(op)) {
>+        case B3::Width8:
>+            append(ZeroExtend8To32, result, result);
>+            break;
>+        case B3::Width16:
>+            append(ZeroExtend16To32, result, result);
>+            break;
>+        default:
>+            break;
>+        }
>+    };
>+
>+    switch (resultWidth(op)) {
>+    case B3::Width64:
>+        if (accessWidth(op) == B3::Width64)
>+            return result;
>+        sanitize32();
>+        append(Move32, result, result);
>+        break;
>+    case B3::Width32:
>+        sanitize32();
>+        break;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        break;
>+    }
>+
>+    return result;
>+}
>+
>+TypedTmp AirIRGenerator::appendGeneralAtomic(ExtAtomicOpType op, B3::Air::Opcode opcode, B3::Commutativity commutativity, Arg input, Arg address)
>+{
>+    B3::Width accessWidth = Wasm::accessWidth(op);
>+    B3::Width resultWidth = Wasm::resultWidth(op);
>+
>+    auto newTmp = [&]() {
>+        if (accessWidth == B3::Width64)
>+            return g64();
>+        return g32();
>+    };
>+
>+    auto tmp = [&](Arg arg) -> TypedTmp {
>+        if (arg.isTmp())
>+            return TypedTmp(arg.tmp(), accessWidth == B3::Width64 ? Type::I64 : Type::I32);
>+        TypedTmp result = newTmp();
>+        append(Move, arg, result);
>+        return result;
>+    };
>+
>+    auto imm = [&](Arg arg) {
>+        if (arg.isImm())
>+            return arg;
>+        return Arg();
>+    };
>+
>+    auto bitImm = [&](Arg arg) {
>+        if (arg.isBitImm())
>+            return arg;
>+        return Arg();
>+    };
>+
>+#if CPU(X86) || CPU(X86_64)
>+    Tmp eax(X86Registers::eax);
>+    TypedTmp result(eax, resultWidth == B3::Width64 ? Type::I64 : Type::I32);
>+#else
>+    TypedTmp result = resultWidth == B3::Width64 ? g64() : g32();
>+#endif
>+
>+    Tmp oldValue = newTmp();
>+    Tmp newValue = opcode == B3::Air::Nop ? tmp(input) : newTmp();
>+
>+    // We need a CAS loop or a LL/SC loop. Using prepare/attempt jargon, we want:
>+    //
>+    // Block #reloop:
>+    //     Prepare
>+    //     opcode
>+    //     Attempt
>+    //   Successors: Then:#done, Else:#reloop
>+    // Block #done:
>+    //     Move oldValue, result
>+
>+    append(Move, oldValue, result);
>+
>+    auto* beginBlock = m_currentBlock;
>+    auto* reloopBlock = m_code.addBlock();
>+    auto* doneBlock = m_code.addBlock();
>+
>+    append(B3::Air::Jump);
>+    beginBlock->setSuccessors(reloopBlock);
>+    m_currentBlock = reloopBlock;
>+
>+    B3::Air::Opcode prepareOpcode;
>+    if (isX86()) {
>+        switch (accessWidth) {
>+        case B3::Width8:
>+            prepareOpcode = Load8SignedExtendTo32;
>+            break;
>+        case B3::Width16:
>+            prepareOpcode = Load16SignedExtendTo32;
>+            break;
>+        case B3::Width32:
>+            prepareOpcode = Move32;
>+            break;
>+        case B3::Width64:
>+            prepareOpcode = Move;
>+            break;
>+        }
>+    } else {
>+        RELEASE_ASSERT(isARM64());
>+        prepareOpcode = OPCODE_FOR_WIDTH(LoadLinkAcq, accessWidth);
>+    }
>+    appendEffectful(prepareOpcode, address, oldValue);
>+
>+    if (opcode != B3::Air::Nop) {
>+        // FIXME: If we ever have to write this again, we need to find a way to share the code with
>+        // appendBinOp.
>+        // https://bugs.webkit.org/show_bug.cgi?id=169249
>+        if (commutativity == B3::Commutative && imm(input) && isValidForm(opcode, Arg::Imm, Arg::Tmp, Arg::Tmp))
>+            append(opcode, imm(input), oldValue, newValue);
>+        else if (imm(input) && isValidForm(opcode, Arg::Tmp, Arg::Imm, Arg::Tmp))
>+            append(opcode, oldValue, imm(input), newValue);
>+        else if (commutativity == B3::Commutative && bitImm(input) && isValidForm(opcode, Arg::BitImm, Arg::Tmp, Arg::Tmp))
>+            append(opcode, bitImm(input), oldValue, newValue);
>+        else if (isValidForm(opcode, Arg::Tmp, Arg::Tmp, Arg::Tmp))
>+            append(opcode, oldValue, tmp(input), newValue);
>+        else {
>+            append(Move, oldValue, newValue);
>+            if (imm(input) && isValidForm(opcode, Arg::Imm, Arg::Tmp))
>+                append(opcode, imm(input), newValue);
>+            else
>+                append(opcode, tmp(input), newValue);
>+        }
>+    }
>+
>+    if (isX86()) {
>+#if CPU(X86) || CPU(X86_64)
>+        B3::Air::Opcode casOpcode = OPCODE_FOR_WIDTH(BranchAtomicStrongCAS, accessWidth);
>+        append(Move, oldValue, result);
>+        appendEffectful(reloopBlock, casOpcode, Arg::statusCond(MacroAssembler::Success), result, newValue, address);
>+#endif
>+    } else {
>+        RELEASE_ASSERT(isARM64());
>+        TypedTmp boolResult = newTmp();
>+        appendEffectful(reloopBlock, OPCODE_FOR_WIDTH(StoreCondRel, accessWidth), newValue, address, boolResult);
>+        append(BranchTest32, Arg::resCond(MacroAssembler::Zero), boolResult, boolResult);
>+    }
>+    reloopBlock->setSuccessors(doneBlock, reloopBlock);
>+    m_currentBlock = doneBlock;
>+    return result;
>+}
>+
>+TypedTmp AirIRGenerator::appendStrongCAS(ExtAtomicOpType op, TypedTmp expected, TypedTmp value, Arg address)
>+{
>+    B3::Width accessWidth = Wasm::accessWidth(op);
>+    B3::Width resultWidth = Wasm::resultWidth(op);
>+
>+    auto newTmp = [&]() {
>+        if (accessWidth == B3::Width64)
>+            return g64();
>+        return g32();
>+    };
>+
>+    auto tmp = [&](Arg arg) -> TypedTmp {
>+        if (arg.isTmp())
>+            return TypedTmp(arg.tmp(), accessWidth == B3::Width64 ? Type::I64 : Type::I32);
>+        TypedTmp result = newTmp();
>+        append(Move, arg, result);
>+        return result;
>+    };
>+
>+#if CPU(X86) || CPU(X86_64)
>+    Tmp eax(X86Registers::eax);
>+    TypedTmp valueResultTmp(eax, resultWidth == B3::Width64 ? Type::I64 : Type::I32);
>+#else
>+    TypedTmp valueResultTmp = resultWidth == B3::Width64 ? g64() : g32();
>+#endif
>+    Tmp successBoolResultTmp = newTmp();
>+
>+    Tmp expectedValueTmp = tmp(expected);
>+    Tmp newValueTmp = tmp(value);
>+
>+    if (isX86()) {
>+        append(Move, expectedValueTmp, valueResultTmp);
>+        appendEffectful(OPCODE_FOR_WIDTH(AtomicStrongCAS, accessWidth), valueResultTmp, newValueTmp, address);
>+        return valueResultTmp;
>+    }
>+
>+    RELEASE_ASSERT(isARM64());
>+    // We wish to emit:
>+    //
>+    // Block #reloop:
>+    //     LoadLink
>+    //     Branch NotEqual
>+    //   Successors: Then:#fail, Else: #store
>+    // Block #store:
>+    //     StoreCond
>+    //     Xor $1, %result    <--- only if !invert
>+    //     Jump
>+    //   Successors: #done
>+    // Block #fail:
>+    //     Move $invert, %result
>+    //     Jump
>+    //   Successors: #done
>+    // Block #done:
>+
>+    auto* reloopBlock = m_code.addBlock();
>+    auto* storeBlock = m_code.addBlock();
>+    auto* strongFailBlock = m_code.addBlock();
>+    auto* doneBlock = m_code.addBlock();
>+    auto* beginBlock = m_currentBlock;
>+
>+    append(B3::Air::Jump);
>+    beginBlock->setSuccessors(reloopBlock);
>+
>+    m_currentBlock = reloopBlock;
>+    appendEffectful(OPCODE_FOR_WIDTH(LoadLinkAcq, accessWidth), address, valueResultTmp);
>+    append(OPCODE_FOR_CANONICAL_WIDTH(Branch, accessWidth), Arg::relCond(MacroAssembler::NotEqual), valueResultTmp, expectedValueTmp);
>+    reloopBlock->setSuccessors(B3::Air::FrequentedBlock(strongFailBlock), storeBlock);
>+
>+    m_currentBlock = storeBlock;
>+    appendEffectful(OPCODE_FOR_WIDTH(StoreCondRel, accessWidth), newValueTmp, address, successBoolResultTmp);
>+    append(BranchTest32, Arg::resCond(MacroAssembler::Zero), successBoolResultTmp, successBoolResultTmp);
>+    storeBlock->setSuccessors(doneBlock, reloopBlock);
>+
>+    m_currentBlock = strongFailBlock;
>+    {
>+        TypedTmp tmp = newTmp();
>+        appendEffectful(OPCODE_FOR_WIDTH(StoreCondRel, accessWidth), valueResultTmp, address, tmp);
>+        append(BranchTest32, Arg::resCond(MacroAssembler::Zero), tmp, tmp);
>+    }
>+    strongFailBlock->setSuccessors(B3::Air::FrequentedBlock(doneBlock), reloopBlock);
>+
>+    m_currentBlock = doneBlock;
>+    return valueResultTmp;
>+}
>+
>+inline TypedTmp AirIRGenerator::emitAtomicLoadOp(ExtAtomicOpType op, ExpressionType pointer, uint32_t uoffset)
>+{
>+    uint32_t offset = fixupPointerPlusOffset(pointer, uoffset);
>+
>+    TypedTmp immTmp;
>+    TypedTmp newPtr;
>+
>+    Arg addrArg;
>+    if (Arg::isValidAddrForm(offset, B3::widthForBytes(sizeOfAtomicLoadOp(op)))) {
>+        if (offset == 0)
>+            newPtr = pointer;
>+        else {
>+            newPtr = g64();
>+            append(Lea64, Arg::addr(pointer, offset), newPtr);
>+        }
>+        addrArg = Arg::addr(newPtr);
>+    } else {
>+        immTmp = g64();
>+        newPtr = g64();
>+        append(Move, Arg::bigImm(offset), immTmp);
>+        append(Add64, immTmp, pointer, newPtr);
>+        addrArg = Arg::addr(newPtr);
>+    }
>+
>+    if (accessWidth(op) != B3::Width8) {
>+        emitCheck([&] {
>+            return Inst(BranchTest64, nullptr, Arg::resCond(MacroAssembler::NonZero), newPtr, Arg::bitImm(sizeOfAtomicLoadOp(op) - 1));
>+        }, [=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+    }
>+
>+    Optional<B3::Air::Opcode> opcode;
>+    if (isX86())
>+        opcode = OPCODE_FOR_WIDTH(AtomicXchgAdd, accessWidth(op));
>+    B3::Air::Opcode nonAtomicOpcode = OPCODE_FOR_CANONICAL_WIDTH(Add, accessWidth(op));
>+
>+    if (opcode && isValidForm(opcode.value(), Arg::Tmp, addrArg.kind())) {
>+        TypedTmp result = resultWidth(op) == B3::Width64 ? g64() : g32();
>+        append(Move, Arg::imm(0), result);
>+        appendEffectful(opcode.value(), result, addrArg);
>+        return sanitizeAtomicResult(op, result);
>+    }
>+
>+    return sanitizeAtomicResult(op, appendGeneralAtomic(op, nonAtomicOpcode, B3::Commutative, Arg::imm(0), addrArg));
>+}
>+
>+auto AirIRGenerator::atomicLoad(ExtAtomicOpType op, ExpressionType pointer, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    ASSERT(pointer.tmp().isGP());
>+
>+    if (UNLIKELY(sumOverflows<uint32_t>(offset, sizeOfAtomicLoadOp(op)))) {
>+        // FIXME: Even though this is provably out of bounds, it's not a validation error, so we have to handle it
>+        // as a runtime exception. However, this may change: https://bugs.webkit.org/show_bug.cgi?id=166435
>+        auto* patch = addPatchpoint(B3::Void);
>+        patch->setGenerator([this] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+        emitPatchpoint(patch, Tmp());
>+
>+        // We won't reach here, so we just pick a random reg.
>+        switch (resultWidth(op)) {
>+        case B3::Width8:
>+        case B3::Width16:
>+        case B3::Width32:
>+            result = g32();
>+            break;
>+        case B3::Width64:
>+            result = g64();
>+            break;
>+        }
>+    } else
>+        result = emitAtomicLoadOp(op, emitCheckAndPreparePointer(pointer, offset, sizeOfAtomicLoadOp(op)), offset);
>+
>+    return { };
>+}
>+
>+inline void AirIRGenerator::emitAtomicStoreOp(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, uint32_t uoffset)
>+{
>+    uint32_t offset = fixupPointerPlusOffset(pointer, uoffset);
>+
>+    TypedTmp immTmp;
>+    TypedTmp newPtr;
>+
>+    Arg addrArg;
>+    if (Arg::isValidAddrForm(offset, B3::widthForBytes(sizeOfAtomicLoadOp(op)))) {
>+        if (offset == 0)
>+            newPtr = pointer;
>+        else {
>+            newPtr = g64();
>+            append(Lea64, Arg::addr(pointer, offset), newPtr);
>+        }
>+        addrArg = Arg::addr(newPtr);
>+    } else {
>+        immTmp = g64();
>+        newPtr = g64();
>+        append(Move, Arg::bigImm(offset), immTmp);
>+        append(Add64, immTmp, pointer, newPtr);
>+        addrArg = Arg::addr(newPtr);
>+    }
>+
>+    if (accessWidth(op) != B3::Width8) {
>+        emitCheck([&] {
>+            return Inst(BranchTest64, nullptr, Arg::resCond(MacroAssembler::NonZero), newPtr, Arg::bitImm(sizeOfAtomicLoadOp(op) - 1));
>+        }, [=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+    }
>+
>+    Optional<B3::Air::Opcode> opcode;
>+    if (isX86())
>+        opcode = OPCODE_FOR_WIDTH(AtomicXchg, accessWidth(op));
>+    B3::Air::Opcode nonAtomicOpcode = B3::Air::Nop;
>+
>+    if (opcode && isValidForm(opcode.value(), Arg::Tmp, addrArg.kind())) {
>+        TypedTmp result = resultWidth(op) == B3::Width64 ? g64() : g32();
>+        append(Move, value, result);
>+        appendEffectful(opcode.value(), result, addrArg);
>+        return;
>+    }
>+
>+    appendGeneralAtomic(op, nonAtomicOpcode, B3::Commutative, value, addrArg);
>+}
>+
>+auto AirIRGenerator::atomicStore(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, uint32_t offset) -> PartialResult
>+{
>+    ASSERT(pointer.tmp().isGP());
>+
>+    if (UNLIKELY(sumOverflows<uint32_t>(offset, sizeOfAtomicLoadOp(op)))) {
>+        // FIXME: Even though this is provably out of bounds, it's not a validation error, so we have to handle it
>+        // as a runtime exception. However, this may change: https://bugs.webkit.org/show_bug.cgi?id=166435
>+        auto* throwException = addPatchpoint(B3::Void);
>+        throwException->setGenerator([this] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+        emitPatchpoint(throwException, Tmp());
>+    } else
>+        emitAtomicStoreOp(op, emitCheckAndPreparePointer(pointer, offset, sizeOfAtomicLoadOp(op)), value, offset);
>+
>+    return { };
>+}
>+
>+TypedTmp AirIRGenerator::emitAtomicBinaryRMWOp(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, uint32_t uoffset)
>+{
>+    uint32_t offset = fixupPointerPlusOffset(pointer, uoffset);
>+
>+    TypedTmp immTmp;
>+    TypedTmp newPtr;
>+
>+    Arg addrArg;
>+    if (Arg::isValidAddrForm(offset, B3::widthForBytes(sizeOfAtomicLoadOp(op)))) {
>+        if (offset == 0)
>+            newPtr = pointer;
>+        else {
>+            newPtr = g64();
>+            append(Lea64, Arg::addr(pointer, offset), newPtr);
>+        }
>+        addrArg = Arg::addr(newPtr);
>+    } else {
>+        immTmp = g64();
>+        newPtr = g64();
>+        append(Move, Arg::bigImm(offset), immTmp);
>+        append(Add64, immTmp, pointer, newPtr);
>+        addrArg = Arg::addr(newPtr);
>+    }
>+
>+    if (accessWidth(op) != B3::Width8) {
>+        emitCheck([&] {
>+            return Inst(BranchTest64, nullptr, Arg::resCond(MacroAssembler::NonZero), newPtr, Arg::bitImm(sizeOfAtomicLoadOp(op) - 1));
>+        }, [=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+    }
>+
>+    Optional<B3::Air::Opcode> opcode;
>+    B3::Air::Opcode nonAtomicOpcode = B3::Air::Nop;
>+    B3::Commutativity commutativity = B3::NotCommutative;
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicRmw8AddU:
>+    case ExtAtomicOpType::I32AtomicRmw16AddU:
>+    case ExtAtomicOpType::I32AtomicRmwAdd:
>+    case ExtAtomicOpType::I64AtomicRmw8AddU:
>+    case ExtAtomicOpType::I64AtomicRmw16AddU:
>+    case ExtAtomicOpType::I64AtomicRmw32AddU:
>+    case ExtAtomicOpType::I64AtomicRmwAdd:
>+        if (isX86())
>+            opcode = OPCODE_FOR_WIDTH(AtomicXchgAdd, accessWidth(op));
>+        nonAtomicOpcode = OPCODE_FOR_CANONICAL_WIDTH(Add, accessWidth(op));
>+        commutativity = B3::Commutative;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8SubU:
>+    case ExtAtomicOpType::I32AtomicRmw16SubU:
>+    case ExtAtomicOpType::I32AtomicRmwSub:
>+    case ExtAtomicOpType::I64AtomicRmw8SubU:
>+    case ExtAtomicOpType::I64AtomicRmw16SubU:
>+    case ExtAtomicOpType::I64AtomicRmw32SubU:
>+    case ExtAtomicOpType::I64AtomicRmwSub:
>+        if (isX86()) {
>+            if (resultWidth(op) == B3::Width64)
>+                append(Neg64, value);
>+            else
>+                append(Neg32, value);
>+            opcode = OPCODE_FOR_WIDTH(AtomicXchgAdd, accessWidth(op));
>+            nonAtomicOpcode = OPCODE_FOR_CANONICAL_WIDTH(Add, accessWidth(op));
>+            commutativity = B3::Commutative;
>+        } else {
>+            nonAtomicOpcode = OPCODE_FOR_CANONICAL_WIDTH(Sub, accessWidth(op));
>+            commutativity = B3::NotCommutative;
>+        }
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8AndU:
>+    case ExtAtomicOpType::I32AtomicRmw16AndU:
>+    case ExtAtomicOpType::I32AtomicRmwAnd:
>+    case ExtAtomicOpType::I64AtomicRmw8AndU:
>+    case ExtAtomicOpType::I64AtomicRmw16AndU:
>+    case ExtAtomicOpType::I64AtomicRmw32AndU:
>+    case ExtAtomicOpType::I64AtomicRmwAnd:
>+        nonAtomicOpcode = OPCODE_FOR_CANONICAL_WIDTH(And, accessWidth(op));
>+        commutativity = B3::Commutative;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8OrU:
>+    case ExtAtomicOpType::I32AtomicRmw16OrU:
>+    case ExtAtomicOpType::I32AtomicRmwOr:
>+    case ExtAtomicOpType::I64AtomicRmw8OrU:
>+    case ExtAtomicOpType::I64AtomicRmw16OrU:
>+    case ExtAtomicOpType::I64AtomicRmw32OrU:
>+    case ExtAtomicOpType::I64AtomicRmwOr:
>+        nonAtomicOpcode = OPCODE_FOR_CANONICAL_WIDTH(Or, accessWidth(op));
>+        commutativity = B3::Commutative;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8XorU:
>+    case ExtAtomicOpType::I32AtomicRmw16XorU:
>+    case ExtAtomicOpType::I32AtomicRmwXor:
>+    case ExtAtomicOpType::I64AtomicRmw8XorU:
>+    case ExtAtomicOpType::I64AtomicRmw16XorU:
>+    case ExtAtomicOpType::I64AtomicRmw32XorU:
>+    case ExtAtomicOpType::I64AtomicRmwXor:
>+        nonAtomicOpcode = OPCODE_FOR_CANONICAL_WIDTH(Xor, accessWidth(op));
>+        commutativity = B3::Commutative;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I32AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I32AtomicRmwXchg:
>+    case ExtAtomicOpType::I64AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw32XchgU:
>+    case ExtAtomicOpType::I64AtomicRmwXchg:
>+        if (isX86())
>+            opcode = OPCODE_FOR_WIDTH(AtomicXchg, accessWidth(op));
>+        nonAtomicOpcode = B3::Air::Nop;
>+        break;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        break;
>+    }
>+
>+    if (opcode && isValidForm(opcode.value(), Arg::Tmp, addrArg.kind())) {
>+        TypedTmp result = resultWidth(op) == B3::Width64 ? g64() : g32();
>+        append(Move, value, result);
>+        appendEffectful(opcode.value(), result, addrArg);
>+        return sanitizeAtomicResult(op, result);
>+    }
>+
>+    return sanitizeAtomicResult(op, appendGeneralAtomic(op, nonAtomicOpcode, commutativity, value, addrArg));
>+}
>+
>+auto AirIRGenerator::atomicBinaryRMW(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    ASSERT(pointer.tmp().isGP());
>+
>+    if (UNLIKELY(sumOverflows<uint32_t>(offset, sizeOfAtomicLoadOp(op)))) {
>+        // FIXME: Even though this is provably out of bounds, it's not a validation error, so we have to handle it
>+        // as a runtime exception. However, this may change: https://bugs.webkit.org/show_bug.cgi?id=166435
>+        auto* patch = addPatchpoint(B3::Void);
>+        patch->setGenerator([this] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+        emitPatchpoint(patch, Tmp());
>+
>+        // We won't reach here, so we just pick a random reg.
>+        switch (resultWidth(op)) {
>+        case B3::Width8:
>+        case B3::Width16:
>+        case B3::Width32:
>+            result = g32();
>+            break;
>+        case B3::Width64:
>+            result = g64();
>+            break;
>+        }
>+    } else
>+        result = emitAtomicBinaryRMWOp(op, emitCheckAndPreparePointer(pointer, offset, sizeOfAtomicLoadOp(op)), value, offset);
>+
>+    return { };
>+}
>+
>+TypedTmp AirIRGenerator::emitAtomicCompareExchange(ExtAtomicOpType op, ExpressionType pointer, ExpressionType expected, ExpressionType value, uint32_t uoffset)
>+{
>+    uint32_t offset = fixupPointerPlusOffset(pointer, uoffset);
>+
>+    TypedTmp immTmp;
>+    TypedTmp newPtr;
>+
>+    Arg addrArg;
>+    if (Arg::isValidAddrForm(offset, B3::widthForBytes(sizeOfAtomicLoadOp(op)))) {
>+        if (offset == 0)
>+            newPtr = pointer;
>+        else {
>+            newPtr = g64();
>+            append(Lea64, Arg::addr(pointer, offset), newPtr);
>+        }
>+        addrArg = Arg::addr(newPtr);
>+    } else {
>+        immTmp = g64();
>+        newPtr = g64();
>+        append(Move, Arg::bigImm(offset), immTmp);
>+        append(Add64, immTmp, pointer, newPtr);
>+        addrArg = Arg::addr(newPtr);
>+    }
>+
>+    if (accessWidth(op) != B3::Width8) {
>+        emitCheck([&] {
>+            return Inst(BranchTest64, nullptr, Arg::resCond(MacroAssembler::NonZero), newPtr, Arg::bitImm(sizeOfAtomicLoadOp(op) - 1));
>+        }, [=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+    }
>+
>+    return sanitizeAtomicResult(op, appendStrongCAS(op, expected, value, addrArg));
>+}
>+
>+auto AirIRGenerator::atomicCompareExchange(ExtAtomicOpType op, ExpressionType pointer, ExpressionType expected, ExpressionType value, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    ASSERT(pointer.tmp().isGP());
>+
>+    if (UNLIKELY(sumOverflows<uint32_t>(offset, sizeOfAtomicLoadOp(op)))) {
>+        // FIXME: Even though this is provably out of bounds, it's not a validation error, so we have to handle it
>+        // as a runtime exception. However, this may change: https://bugs.webkit.org/show_bug.cgi?id=166435
>+        auto* patch = addPatchpoint(B3::Void);
>+        patch->setGenerator([this] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+        emitPatchpoint(patch, Tmp());
>+
>+        // We won't reach here, so we just pick a random reg.
>+        switch (resultWidth(op)) {
>+        case B3::Width8:
>+        case B3::Width16:
>+        case B3::Width32:
>+            result = g32();
>+            break;
>+        case B3::Width64:
>+            result = g64();
>+            break;
>+        }
>+    } else
>+        result = emitAtomicCompareExchange(op, emitCheckAndPreparePointer(pointer, offset, sizeOfAtomicLoadOp(op)), expected, value, offset);
>+
>+    return { };
>+}
>+
>+auto AirIRGenerator::atomicWait(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, ExpressionType timeout, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    result = g32();
>+
>+    if (op == ExtAtomicOpType::MemoryAtomicWait32)
>+        emitCCall(&operationMemoryAtomicWait32, result, instanceValue(), pointer, addConstant(Type::I32, offset), value, timeout);
>+    else
>+        emitCCall(&operationMemoryAtomicWait64, result, instanceValue(), pointer, addConstant(Type::I32, offset), value, timeout);
>+    emitCheck([&] {
>+        return Inst(Branch32, nullptr, Arg::relCond(MacroAssembler::LessThan), result, Arg::imm(0));
>+    }, [=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+        this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+    });
>+
>+    return { };
>+}
>+
>+auto AirIRGenerator::atomicNotify(ExtAtomicOpType, ExpressionType pointer, ExpressionType count, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    result = g32();
>+
>+    emitCCall(&operationMemoryAtomicNotify, result, instanceValue(), pointer, addConstant(Type::I32, offset), count);
>+    emitCheck([&] {
>+        return Inst(Branch32, nullptr, Arg::relCond(MacroAssembler::LessThan), result, Arg::imm(0));
>+    }, [=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+        this->emitThrowException(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+    });
>+
>+    return { };
>+}
>+
> auto AirIRGenerator::addSelect(ExpressionType condition, ExpressionType nonZero, ExpressionType zero, ExpressionType& result) -> PartialResult
> {
>     ASSERT(nonZero.type() == zero.type());
>diff --git a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp b/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp
>index 96f3aacf96b4220118ebcfe8e1c185c2d7f3ece3..74ceb45107a4c1633fd87fc0c27b8f6db135b668 100644
>--- a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp
>+++ b/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp
>@@ -232,6 +232,14 @@ class B3IRGenerator {
>     PartialResult WARN_UNUSED_RETURN addGrowMemory(ExpressionType delta, ExpressionType& result);
>     PartialResult WARN_UNUSED_RETURN addCurrentMemory(ExpressionType& result);
> 
>+    // Atomics
>+    PartialResult WARN_UNUSED_RETURN atomicLoad(ExtAtomicOpType, ExpressionType pointer, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicStore(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicBinaryRMW(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicCompareExchange(ExtAtomicOpType, ExpressionType pointer, ExpressionType expected, ExpressionType value, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicWait(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType timeout, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicNotify(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset);
>+
>     // Basic operators
>     template<OpType>
>     PartialResult WARN_UNUSED_RETURN addOp(ExpressionType arg, ExpressionType& result);
>@@ -285,12 +293,19 @@ class B3IRGenerator {
>     ExpressionType emitLoadOp(LoadOpType, ExpressionType pointer, uint32_t offset);
>     void emitStoreOp(StoreOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
> 
>+    ExpressionType sanitizeAtomicResult(ExtAtomicOpType, ExpressionType result);
>+    ExpressionType emitAtomicLoadOp(ExtAtomicOpType, ExpressionType pointer, uint32_t offset);
>+    void emitAtomicStoreOp(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
>+    ExpressionType emitAtomicBinaryRMWOp(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
>+    ExpressionType emitAtomicCompareExchange(ExtAtomicOpType, ExpressionType pointer, ExpressionType expected, ExpressionType value, uint32_t offset);
>+
>     void unify(const ExpressionType phi, const ExpressionType source);
>     void unifyValuesWithBlock(const Stack& resultStack, const ResultList& stack);
> 
>     void emitChecksForModOrDiv(B3::Opcode, ExpressionType left, ExpressionType right);
> 
>     int32_t WARN_UNUSED_RETURN fixupPointerPlusOffset(ExpressionType&, uint32_t);
>+    ExpressionType WARN_UNUSED_RETURN fixupPointerPlusOffsetForAtomicOps(ExtAtomicOpType, ExpressionType, uint32_t);
> 
>     void restoreWasmContextInstance(Procedure&, BasicBlock*, Value*);
>     enum class RestoreCachedStackLimit { No, Yes };
>@@ -1203,6 +1218,455 @@ auto B3IRGenerator::store(StoreOpType op, ExpressionType pointer, ExpressionType
>     return { };
> }
> 
>+inline B3::Width accessWidth(ExtAtomicOpType op)
>+{
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicLoad8U:
>+    case ExtAtomicOpType::I32AtomicStore8U:
>+    case ExtAtomicOpType::I32AtomicRmw8AddU:
>+    case ExtAtomicOpType::I32AtomicRmw8SubU:
>+    case ExtAtomicOpType::I32AtomicRmw8AndU:
>+    case ExtAtomicOpType::I32AtomicRmw8OrU:
>+    case ExtAtomicOpType::I32AtomicRmw8XorU:
>+    case ExtAtomicOpType::I32AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I32AtomicRmw8CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicLoad8U:
>+    case ExtAtomicOpType::I64AtomicStore8U:
>+    case ExtAtomicOpType::I64AtomicRmw8AddU:
>+    case ExtAtomicOpType::I64AtomicRmw8SubU:
>+    case ExtAtomicOpType::I64AtomicRmw8AndU:
>+    case ExtAtomicOpType::I64AtomicRmw8OrU:
>+    case ExtAtomicOpType::I64AtomicRmw8XorU:
>+    case ExtAtomicOpType::I64AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw8CmpxchgU:
>+        return B3::Width8;
>+    case ExtAtomicOpType::I32AtomicLoad16U:
>+    case ExtAtomicOpType::I32AtomicStore16U:
>+    case ExtAtomicOpType::I32AtomicRmw16AddU:
>+    case ExtAtomicOpType::I32AtomicRmw16SubU:
>+    case ExtAtomicOpType::I32AtomicRmw16AndU:
>+    case ExtAtomicOpType::I32AtomicRmw16OrU:
>+    case ExtAtomicOpType::I32AtomicRmw16XorU:
>+    case ExtAtomicOpType::I32AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I32AtomicRmw16CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicLoad16U:
>+    case ExtAtomicOpType::I64AtomicStore16U:
>+    case ExtAtomicOpType::I64AtomicRmw16AddU:
>+    case ExtAtomicOpType::I64AtomicRmw16SubU:
>+    case ExtAtomicOpType::I64AtomicRmw16AndU:
>+    case ExtAtomicOpType::I64AtomicRmw16OrU:
>+    case ExtAtomicOpType::I64AtomicRmw16XorU:
>+    case ExtAtomicOpType::I64AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw16CmpxchgU:
>+        return B3::Width16;
>+    case ExtAtomicOpType::I32AtomicLoad:
>+    case ExtAtomicOpType::I32AtomicStore:
>+    case ExtAtomicOpType::I32AtomicRmwAdd:
>+    case ExtAtomicOpType::I32AtomicRmwSub:
>+    case ExtAtomicOpType::I32AtomicRmwAnd:
>+    case ExtAtomicOpType::I32AtomicRmwOr:
>+    case ExtAtomicOpType::I32AtomicRmwXor:
>+    case ExtAtomicOpType::I32AtomicRmwXchg:
>+    case ExtAtomicOpType::I32AtomicRmwCmpxchg:
>+    case ExtAtomicOpType::I64AtomicLoad32U:
>+    case ExtAtomicOpType::I64AtomicStore32U:
>+    case ExtAtomicOpType::I64AtomicRmw32AddU:
>+    case ExtAtomicOpType::I64AtomicRmw32SubU:
>+    case ExtAtomicOpType::I64AtomicRmw32AndU:
>+    case ExtAtomicOpType::I64AtomicRmw32OrU:
>+    case ExtAtomicOpType::I64AtomicRmw32XorU:
>+    case ExtAtomicOpType::I64AtomicRmw32XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw32CmpxchgU:
>+        return B3::Width32;
>+    case ExtAtomicOpType::I64AtomicLoad:
>+    case ExtAtomicOpType::I64AtomicStore:
>+    case ExtAtomicOpType::I64AtomicRmwAdd:
>+    case ExtAtomicOpType::I64AtomicRmwSub:
>+    case ExtAtomicOpType::I64AtomicRmwAnd:
>+    case ExtAtomicOpType::I64AtomicRmwOr:
>+    case ExtAtomicOpType::I64AtomicRmwXor:
>+    case ExtAtomicOpType::I64AtomicRmwXchg:
>+    case ExtAtomicOpType::I64AtomicRmwCmpxchg:
>+        return B3::Width64;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        return B3::Width8;
>+    }
>+}
>+
>+inline B3::Width resultWidth(ExtAtomicOpType op)
>+{
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicLoad8U:
>+    case ExtAtomicOpType::I32AtomicLoad16U:
>+    case ExtAtomicOpType::I32AtomicLoad:
>+    case ExtAtomicOpType::I32AtomicStore8U:
>+    case ExtAtomicOpType::I32AtomicStore16U:
>+    case ExtAtomicOpType::I32AtomicStore:
>+    case ExtAtomicOpType::I32AtomicRmw8AddU:
>+    case ExtAtomicOpType::I32AtomicRmw16AddU:
>+    case ExtAtomicOpType::I32AtomicRmwAdd:
>+    case ExtAtomicOpType::I32AtomicRmw8SubU:
>+    case ExtAtomicOpType::I32AtomicRmw16SubU:
>+    case ExtAtomicOpType::I32AtomicRmwSub:
>+    case ExtAtomicOpType::I32AtomicRmw8AndU:
>+    case ExtAtomicOpType::I32AtomicRmw16AndU:
>+    case ExtAtomicOpType::I32AtomicRmwAnd:
>+    case ExtAtomicOpType::I32AtomicRmw8OrU:
>+    case ExtAtomicOpType::I32AtomicRmw16OrU:
>+    case ExtAtomicOpType::I32AtomicRmwOr:
>+    case ExtAtomicOpType::I32AtomicRmw8XorU:
>+    case ExtAtomicOpType::I32AtomicRmw16XorU:
>+    case ExtAtomicOpType::I32AtomicRmwXor:
>+    case ExtAtomicOpType::I32AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I32AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I32AtomicRmwXchg:
>+    case ExtAtomicOpType::I32AtomicRmw8CmpxchgU:
>+    case ExtAtomicOpType::I32AtomicRmw16CmpxchgU:
>+    case ExtAtomicOpType::I32AtomicRmwCmpxchg:
>+        return B3::Width32;
>+    case ExtAtomicOpType::I64AtomicLoad8U:
>+    case ExtAtomicOpType::I64AtomicLoad16U:
>+    case ExtAtomicOpType::I64AtomicLoad32U:
>+    case ExtAtomicOpType::I64AtomicLoad:
>+    case ExtAtomicOpType::I64AtomicStore8U:
>+    case ExtAtomicOpType::I64AtomicStore16U:
>+    case ExtAtomicOpType::I64AtomicStore32U:
>+    case ExtAtomicOpType::I64AtomicStore:
>+    case ExtAtomicOpType::I64AtomicRmw8AddU:
>+    case ExtAtomicOpType::I64AtomicRmw16AddU:
>+    case ExtAtomicOpType::I64AtomicRmw32AddU:
>+    case ExtAtomicOpType::I64AtomicRmwAdd:
>+    case ExtAtomicOpType::I64AtomicRmw8SubU:
>+    case ExtAtomicOpType::I64AtomicRmw16SubU:
>+    case ExtAtomicOpType::I64AtomicRmw32SubU:
>+    case ExtAtomicOpType::I64AtomicRmwSub:
>+    case ExtAtomicOpType::I64AtomicRmw8AndU:
>+    case ExtAtomicOpType::I64AtomicRmw16AndU:
>+    case ExtAtomicOpType::I64AtomicRmw32AndU:
>+    case ExtAtomicOpType::I64AtomicRmwAnd:
>+    case ExtAtomicOpType::I64AtomicRmw8OrU:
>+    case ExtAtomicOpType::I64AtomicRmw16OrU:
>+    case ExtAtomicOpType::I64AtomicRmw32OrU:
>+    case ExtAtomicOpType::I64AtomicRmwOr:
>+    case ExtAtomicOpType::I64AtomicRmw8XorU:
>+    case ExtAtomicOpType::I64AtomicRmw16XorU:
>+    case ExtAtomicOpType::I64AtomicRmw32XorU:
>+    case ExtAtomicOpType::I64AtomicRmwXor:
>+    case ExtAtomicOpType::I64AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw32XchgU:
>+    case ExtAtomicOpType::I64AtomicRmwXchg:
>+    case ExtAtomicOpType::I64AtomicRmw8CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicRmw16CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicRmw32CmpxchgU:
>+    case ExtAtomicOpType::I64AtomicRmwCmpxchg:
>+        return B3::Width64;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        return B3::Width8;
>+    }
>+}
>+
>+inline uint32_t sizeOfAtomicLoadOp(ExtAtomicOpType op)
>+{
>+    return bytesForWidth(accessWidth(op));
>+}
>+
>+inline Value* B3IRGenerator::sanitizeAtomicResult(ExtAtomicOpType op, ExpressionType result)
>+{
>+    auto sanitize32 = [&](ExpressionType result) {
>+        switch (accessWidth(op)) {
>+        case B3::Width8:
>+            return m_currentBlock->appendNew<Value>(m_proc, BitAnd, origin(), result, constant(Int32, 0xff));
>+        case B3::Width16:
>+            return m_currentBlock->appendNew<Value>(m_proc, BitAnd, origin(), result, constant(Int32, 0xffff));
>+        default:
>+            return result;
>+        }
>+    };
>+
>+    switch (resultWidth(op)) {
>+    case B3::Width64: {
>+        if (accessWidth(op) == B3::Width64)
>+            return result;
>+        return m_currentBlock->appendNew<Value>(m_proc, ZExt32, origin(), sanitize32(result));
>+    }
>+    case B3::Width32:
>+        return sanitize32(result);
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        return nullptr;
>+    }
>+}
>+
>+Value* B3IRGenerator::fixupPointerPlusOffsetForAtomicOps(ExtAtomicOpType op, ExpressionType ptr, uint32_t offset)
>+{
>+    auto pointer = m_currentBlock->appendNew<Value>(m_proc, Add, origin(), ptr, m_currentBlock->appendNew<Const64Value>(m_proc, origin(), offset));
>+    if (accessWidth(op) != B3::Width8) {
>+        CheckValue* check = m_currentBlock->appendNew<CheckValue>(m_proc, Check, origin(),
>+            m_currentBlock->appendNew<Value>(m_proc, BitAnd, origin(), pointer, constant(pointerType(), sizeOfAtomicLoadOp(op) - 1)));
>+        check->setGenerator([=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+    }
>+    return pointer;
>+}
>+
>+inline Value* B3IRGenerator::emitAtomicLoadOp(ExtAtomicOpType op, ExpressionType pointer, uint32_t uoffset)
>+{
>+    pointer = fixupPointerPlusOffsetForAtomicOps(op, pointer, uoffset);
>+
>+    ExpressionType value = nullptr;
>+    switch (accessWidth(op)) {
>+    case B3::Width8:
>+    case B3::Width16:
>+    case B3::Width32:
>+        value = constant(Int32, 0);
>+        break;
>+    case B3::Width64:
>+        value = constant(Int64, 0);
>+        break;
>+    }
>+
>+    return sanitizeAtomicResult(op, m_currentBlock->appendNew<AtomicValue>(m_proc, memoryKind(AtomicXchgAdd), origin(), accessWidth(op), value, pointer));
>+}
>+
>+auto B3IRGenerator::atomicLoad(ExtAtomicOpType op, ExpressionType pointer, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    ASSERT(pointer->type() == Int32);
>+
>+    if (UNLIKELY(sumOverflows<uint32_t>(offset, sizeOfAtomicLoadOp(op)))) {
>+        // FIXME: Even though this is provably out of bounds, it's not a validation error, so we have to handle it
>+        // as a runtime exception. However, this may change: https://bugs.webkit.org/show_bug.cgi?id=166435
>+        B3::PatchpointValue* throwException = m_currentBlock->appendNew<B3::PatchpointValue>(m_proc, B3::Void, origin());
>+        throwException->setGenerator([this] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+
>+        switch (resultWidth(op)) {
>+        case B3::Width8:
>+        case B3::Width16:
>+        case B3::Width32:
>+            result = constant(Int32, 0);
>+            break;
>+        case B3::Width64:
>+            result = constant(Int64, 0);
>+            break;
>+        }
>+    } else
>+        result = emitAtomicLoadOp(op, emitCheckAndPreparePointer(pointer, offset, sizeOfAtomicLoadOp(op)), offset);
>+
>+    return { };
>+}
>+
>+inline void B3IRGenerator::emitAtomicStoreOp(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, uint32_t uoffset)
>+{
>+    pointer = fixupPointerPlusOffsetForAtomicOps(op, pointer, uoffset);
>+
>+    if (resultWidth(op) == B3::Width64 && accessWidth(op) != B3::Width64)
>+        value = m_currentBlock->appendNew<B3::Value>(m_proc, B3::Trunc, Origin(), value);
>+    m_currentBlock->appendNew<AtomicValue>(m_proc, memoryKind(AtomicXchg), origin(), accessWidth(op), value, pointer);
>+}
>+
>+auto B3IRGenerator::atomicStore(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, uint32_t offset) -> PartialResult
>+{
>+    ASSERT(pointer->type() == Int32);
>+
>+    if (UNLIKELY(sumOverflows<uint32_t>(offset, sizeOfAtomicLoadOp(op)))) {
>+        // FIXME: Even though this is provably out of bounds, it's not a validation error, so we have to handle it
>+        // as a runtime exception. However, this may change: https://bugs.webkit.org/show_bug.cgi?id=166435
>+        B3::PatchpointValue* throwException = m_currentBlock->appendNew<B3::PatchpointValue>(m_proc, B3::Void, origin());
>+        throwException->setGenerator([this] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+    } else
>+        emitAtomicStoreOp(op, emitCheckAndPreparePointer(pointer, offset, sizeOfAtomicLoadOp(op)), value, offset);
>+
>+    return { };
>+}
>+
>+inline Value* B3IRGenerator::emitAtomicBinaryRMWOp(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, uint32_t uoffset)
>+{
>+    pointer = fixupPointerPlusOffsetForAtomicOps(op, pointer, uoffset);
>+
>+    B3::Opcode opcode = B3::Nop;
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicRmw8AddU:
>+    case ExtAtomicOpType::I32AtomicRmw16AddU:
>+    case ExtAtomicOpType::I32AtomicRmwAdd:
>+    case ExtAtomicOpType::I64AtomicRmw8AddU:
>+    case ExtAtomicOpType::I64AtomicRmw16AddU:
>+    case ExtAtomicOpType::I64AtomicRmw32AddU:
>+    case ExtAtomicOpType::I64AtomicRmwAdd:
>+        opcode = AtomicXchgAdd;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8SubU:
>+    case ExtAtomicOpType::I32AtomicRmw16SubU:
>+    case ExtAtomicOpType::I32AtomicRmwSub:
>+    case ExtAtomicOpType::I64AtomicRmw8SubU:
>+    case ExtAtomicOpType::I64AtomicRmw16SubU:
>+    case ExtAtomicOpType::I64AtomicRmw32SubU:
>+    case ExtAtomicOpType::I64AtomicRmwSub:
>+        opcode = AtomicXchgSub;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8AndU:
>+    case ExtAtomicOpType::I32AtomicRmw16AndU:
>+    case ExtAtomicOpType::I32AtomicRmwAnd:
>+    case ExtAtomicOpType::I64AtomicRmw8AndU:
>+    case ExtAtomicOpType::I64AtomicRmw16AndU:
>+    case ExtAtomicOpType::I64AtomicRmw32AndU:
>+    case ExtAtomicOpType::I64AtomicRmwAnd:
>+        opcode = AtomicXchgAnd;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8OrU:
>+    case ExtAtomicOpType::I32AtomicRmw16OrU:
>+    case ExtAtomicOpType::I32AtomicRmwOr:
>+    case ExtAtomicOpType::I64AtomicRmw8OrU:
>+    case ExtAtomicOpType::I64AtomicRmw16OrU:
>+    case ExtAtomicOpType::I64AtomicRmw32OrU:
>+    case ExtAtomicOpType::I64AtomicRmwOr:
>+        opcode = AtomicXchgOr;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8XorU:
>+    case ExtAtomicOpType::I32AtomicRmw16XorU:
>+    case ExtAtomicOpType::I32AtomicRmwXor:
>+    case ExtAtomicOpType::I64AtomicRmw8XorU:
>+    case ExtAtomicOpType::I64AtomicRmw16XorU:
>+    case ExtAtomicOpType::I64AtomicRmw32XorU:
>+    case ExtAtomicOpType::I64AtomicRmwXor:
>+        opcode = AtomicXchgXor;
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I32AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I32AtomicRmwXchg:
>+    case ExtAtomicOpType::I64AtomicRmw8XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw16XchgU:
>+    case ExtAtomicOpType::I64AtomicRmw32XchgU:
>+    case ExtAtomicOpType::I64AtomicRmwXchg:
>+        opcode = AtomicXchg;
>+        break;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        break;
>+    }
>+
>+    if (resultWidth(op) == B3::Width64 && accessWidth(op) != B3::Width64)
>+        value = m_currentBlock->appendNew<B3::Value>(m_proc, B3::Trunc, Origin(), value);
>+
>+    return sanitizeAtomicResult(op, m_currentBlock->appendNew<AtomicValue>(m_proc, memoryKind(opcode), origin(), accessWidth(op), value, pointer));
>+}
>+
>+auto B3IRGenerator::atomicBinaryRMW(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    ASSERT(pointer->type() == Int32);
>+
>+    if (UNLIKELY(sumOverflows<uint32_t>(offset, sizeOfAtomicLoadOp(op)))) {
>+        // FIXME: Even though this is provably out of bounds, it's not a validation error, so we have to handle it
>+        // as a runtime exception. However, this may change: https://bugs.webkit.org/show_bug.cgi?id=166435
>+        B3::PatchpointValue* throwException = m_currentBlock->appendNew<B3::PatchpointValue>(m_proc, B3::Void, origin());
>+        throwException->setGenerator([this] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+
>+        switch (resultWidth(op)) {
>+        case B3::Width8:
>+        case B3::Width16:
>+        case B3::Width32:
>+            result = constant(Int32, 0);
>+            break;
>+        case B3::Width64:
>+            result = constant(Int64, 0);
>+            break;
>+        }
>+    } else
>+        result = emitAtomicBinaryRMWOp(op, emitCheckAndPreparePointer(pointer, offset, sizeOfAtomicLoadOp(op)), value, offset);
>+
>+    return { };
>+}
>+
>+Value* B3IRGenerator::emitAtomicCompareExchange(ExtAtomicOpType op, ExpressionType pointer, ExpressionType expected, ExpressionType value, uint32_t offset)
>+{
>+    pointer = fixupPointerPlusOffsetForAtomicOps(op, pointer, offset);
>+
>+    if (resultWidth(op) == B3::Width64 && accessWidth(op) != B3::Width64) {
>+        expected = m_currentBlock->appendNew<B3::Value>(m_proc, B3::Trunc, Origin(), expected);
>+        value = m_currentBlock->appendNew<B3::Value>(m_proc, B3::Trunc, Origin(), value);
>+    }
>+
>+    return sanitizeAtomicResult(op, m_currentBlock->appendNew<AtomicValue>(m_proc, AtomicStrongCAS, origin(), accessWidth(op), expected, value, pointer));
>+}
>+
>+auto B3IRGenerator::atomicCompareExchange(ExtAtomicOpType op, ExpressionType pointer, ExpressionType expected, ExpressionType value, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    ASSERT(pointer->type() == Int32);
>+
>+    if (UNLIKELY(sumOverflows<uint32_t>(offset, sizeOfAtomicLoadOp(op)))) {
>+        // FIXME: Even though this is provably out of bounds, it's not a validation error, so we have to handle it
>+        // as a runtime exception. However, this may change: https://bugs.webkit.org/show_bug.cgi?id=166435
>+        B3::PatchpointValue* throwException = m_currentBlock->appendNew<B3::PatchpointValue>(m_proc, B3::Void, origin());
>+        throwException->setGenerator([this] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+
>+        switch (resultWidth(op)) {
>+        case B3::Width8:
>+        case B3::Width16:
>+        case B3::Width32:
>+            result = constant(Int32, 0);
>+            break;
>+        case B3::Width64:
>+            result = constant(Int64, 0);
>+            break;
>+        }
>+    } else
>+        result = emitAtomicCompareExchange(op, emitCheckAndPreparePointer(pointer, offset, sizeOfAtomicLoadOp(op)), expected, value, offset);
>+
>+    return { };
>+}
>+
>+auto B3IRGenerator::atomicWait(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, ExpressionType timeout, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    if (op == ExtAtomicOpType::MemoryAtomicWait32) {
>+        result = m_currentBlock->appendNew<CCallValue>(m_proc, Int32, origin(),
>+            m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationMemoryAtomicWait32)),
>+            instanceValue(), pointer, m_currentBlock->appendNew<Const32Value>(m_proc, origin(), offset), value, timeout);
>+    } else {
>+        result = m_currentBlock->appendNew<CCallValue>(m_proc, Int32, origin(),
>+            m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationMemoryAtomicWait64)),
>+            instanceValue(), pointer, m_currentBlock->appendNew<Const32Value>(m_proc, origin(), offset), value, timeout);
>+    }
>+
>+    {
>+        CheckValue* check = m_currentBlock->appendNew<CheckValue>(m_proc, Check, origin(),
>+            m_currentBlock->appendNew<Value>(m_proc, LessThan, origin(), result, m_currentBlock->appendNew<Const32Value>(m_proc, origin(), 0)));
>+
>+        check->setGenerator([=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+    }
>+
>+    return { };
>+}
>+
>+auto B3IRGenerator::atomicNotify(ExtAtomicOpType, ExpressionType pointer, ExpressionType count, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    result = m_currentBlock->appendNew<CCallValue>(m_proc, Int32, origin(),
>+        m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationMemoryAtomicNotify)),
>+        instanceValue(), pointer, m_currentBlock->appendNew<Const32Value>(m_proc, origin(), offset), count);
>+
>+    {
>+        CheckValue* check = m_currentBlock->appendNew<CheckValue>(m_proc, Check, origin(),
>+            m_currentBlock->appendNew<Value>(m_proc, LessThan, origin(), result, m_currentBlock->appendNew<Const32Value>(m_proc, origin(), 0)));
>+
>+        check->setGenerator([=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
>+            this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsMemoryAccess);
>+        });
>+    }
>+
>+    return { };
>+}
>+
> auto B3IRGenerator::addSelect(ExpressionType condition, ExpressionType nonZero, ExpressionType zero, ExpressionType& result) -> PartialResult
> {
>     result = m_currentBlock->appendNew<Value>(m_proc, B3::Select, origin(), condition, nonZero, zero);
>diff --git a/Source/JavaScriptCore/wasm/WasmFunctionParser.h b/Source/JavaScriptCore/wasm/WasmFunctionParser.h
>index 08b0a5846a7b16a0f59f275ec268442c654b988c..13021b3199fdacb0e662b019422c211178e22758 100644
>--- a/Source/JavaScriptCore/wasm/WasmFunctionParser.h
>+++ b/Source/JavaScriptCore/wasm/WasmFunctionParser.h
>@@ -127,6 +127,13 @@ class FunctionParser : public Parser<void> {
>     PartialResult WARN_UNUSED_RETURN store(Type memoryType);
>     PartialResult WARN_UNUSED_RETURN load(Type memoryType);
> 
>+    PartialResult WARN_UNUSED_RETURN atomicLoad(ExtAtomicOpType, Type memoryType);
>+    PartialResult WARN_UNUSED_RETURN atomicStore(ExtAtomicOpType, Type memoryType);
>+    PartialResult WARN_UNUSED_RETURN atomicBinaryRMW(ExtAtomicOpType, Type memoryType);
>+    PartialResult WARN_UNUSED_RETURN atomicCompareExchange(ExtAtomicOpType, Type memoryType);
>+    PartialResult WARN_UNUSED_RETURN atomicWait(ExtAtomicOpType, Type memoryType);
>+    PartialResult WARN_UNUSED_RETURN atomicNotify(ExtAtomicOpType);
>+
> #define WASM_TRY_ADD_TO_CONTEXT(add_expression) WASM_FAIL_IF_HELPER_FAILS(m_context.add_expression)
> 
>     template <typename ...Args>
>@@ -316,6 +323,151 @@ auto FunctionParser<Context>::store(Type memoryType) -> PartialResult
>     return { };
> }
> 
>+template<typename Context>
>+auto FunctionParser<Context>::atomicLoad(ExtAtomicOpType op, Type memoryType) -> PartialResult
>+{
>+    WASM_VALIDATOR_FAIL_IF(!m_info.memory, "atomic instruction without memory");
>+
>+    uint32_t alignment;
>+    uint32_t offset;
>+    TypedExpression pointer;
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment");
>+    WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(op), "byte alignment ", 1ull << alignment, " exceeds load's natural alignment ", 1ull << memoryLog2Alignment(op));
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "load pointer");
>+
>+    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
>+
>+    ExpressionType result;
>+    WASM_TRY_ADD_TO_CONTEXT(atomicLoad(op, pointer, result, offset));
>+    m_expressionStack.constructAndAppend(memoryType, result);
>+    return { };
>+}
>+
>+template<typename Context>
>+auto FunctionParser<Context>::atomicStore(ExtAtomicOpType op, Type memoryType) -> PartialResult
>+{
>+    WASM_VALIDATOR_FAIL_IF(!m_info.memory, "atomic instruction without memory");
>+
>+    uint32_t alignment;
>+    uint32_t offset;
>+    TypedExpression value;
>+    TypedExpression pointer;
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get store alignment");
>+    WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(op), "byte alignment ", 1ull << alignment, " exceeds store's natural alignment ", 1ull << memoryLog2Alignment(op));
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get store offset");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "store value");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "store pointer");
>+
>+    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, m_currentOpcode, " pointer type mismatch");
>+    WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, m_currentOpcode, " value type mismatch");
>+
>+    WASM_TRY_ADD_TO_CONTEXT(atomicStore(op, pointer, value, offset));
>+    return { };
>+}
>+
>+template<typename Context>
>+auto FunctionParser<Context>::atomicBinaryRMW(ExtAtomicOpType op, Type memoryType) -> PartialResult
>+{
>+    WASM_VALIDATOR_FAIL_IF(!m_info.memory, "atomic instruction without memory");
>+
>+    uint32_t alignment;
>+    uint32_t offset;
>+    TypedExpression pointer;
>+    TypedExpression value;
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment");
>+    WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(op), "byte alignment ", 1ull << alignment, " exceeds load's natural alignment ", 1ull << memoryLog2Alignment(op));
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "value");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer");
>+
>+    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
>+    WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch");
>+
>+    ExpressionType result;
>+    WASM_TRY_ADD_TO_CONTEXT(atomicBinaryRMW(op, pointer, value, result, offset));
>+    m_expressionStack.constructAndAppend(memoryType, result);
>+    return { };
>+}
>+
>+template<typename Context>
>+auto FunctionParser<Context>::atomicCompareExchange(ExtAtomicOpType op, Type memoryType) -> PartialResult
>+{
>+    WASM_VALIDATOR_FAIL_IF(!m_info.memory, "atomic instruction without memory");
>+
>+    uint32_t alignment;
>+    uint32_t offset;
>+    TypedExpression pointer;
>+    TypedExpression expected;
>+    TypedExpression value;
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment");
>+    WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(op), "byte alignment ", 1ull << alignment, " exceeds load's natural alignment ", 1ull << memoryLog2Alignment(op));
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "value");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(expected, "expected");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer");
>+
>+    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
>+    WASM_VALIDATOR_FAIL_IF(expected.type() != memoryType, static_cast<unsigned>(op), " expected type mismatch");
>+    WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch");
>+
>+    ExpressionType result;
>+    WASM_TRY_ADD_TO_CONTEXT(atomicCompareExchange(op, pointer, expected, value, result, offset));
>+    m_expressionStack.constructAndAppend(memoryType, result);
>+    return { };
>+}
>+
>+template<typename Context>
>+auto FunctionParser<Context>::atomicWait(ExtAtomicOpType op, Type memoryType) -> PartialResult
>+{
>+    WASM_VALIDATOR_FAIL_IF(!m_info.memory, "atomic instruction without memory");
>+
>+    uint32_t alignment;
>+    uint32_t offset;
>+    TypedExpression pointer;
>+    TypedExpression value;
>+    TypedExpression timeout;
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment");
>+    WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(op), "byte alignment ", 1ull << alignment, " exceeds load's natural alignment ", 1ull << memoryLog2Alignment(op));
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(timeout, "timeout");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(value, "value");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer");
>+
>+    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
>+    WASM_VALIDATOR_FAIL_IF(value.type() != memoryType, static_cast<unsigned>(op), " value type mismatch");
>+    WASM_VALIDATOR_FAIL_IF(timeout.type() != I64, static_cast<unsigned>(op), " timeout type mismatch");
>+
>+    ExpressionType result;
>+    WASM_TRY_ADD_TO_CONTEXT(atomicWait(op, pointer, value, timeout, result, offset));
>+    m_expressionStack.constructAndAppend(I32, result);
>+    return { };
>+}
>+
>+template<typename Context>
>+auto FunctionParser<Context>::atomicNotify(ExtAtomicOpType op) -> PartialResult
>+{
>+    WASM_VALIDATOR_FAIL_IF(!m_info.memory, "atomic instruction without memory");
>+
>+    uint32_t alignment;
>+    uint32_t offset;
>+    TypedExpression pointer;
>+    TypedExpression count;
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment");
>+    WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(op), "byte alignment ", 1ull << alignment, " exceeds load's natural alignment ", 1ull << memoryLog2Alignment(op));
>+    WASM_PARSER_FAIL_IF(!parseVarUInt32(offset), "can't get load offset");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(count, "count");
>+    WASM_TRY_POP_EXPRESSION_STACK_INTO(pointer, "pointer");
>+
>+    WASM_VALIDATOR_FAIL_IF(pointer.type() != I32, static_cast<unsigned>(op), " pointer type mismatch");
>+    WASM_VALIDATOR_FAIL_IF(count.type() != I32, static_cast<unsigned>(op), " count type mismatch"); // The spec's definition is saying i64, but all implementations (including tests) are using i32. So looks like the spec is wrong.
>+
>+    ExpressionType result;
>+    WASM_TRY_ADD_TO_CONTEXT(atomicNotify(op, pointer, count, result, offset));
>+    m_expressionStack.constructAndAppend(I32, result);
>+    return { };
>+}
>+
> template<typename Context>
> auto FunctionParser<Context>::checkBranchTarget(const ControlType& target) -> PartialResult
> {
>@@ -491,6 +643,44 @@ FOR_EACH_WASM_MEMORY_STORE_OP(CREATE_CASE)
>         return { };
>     }
> 
>+    case ExtAtomic: {
>+        WASM_PARSER_FAIL_IF(!Options::useWebAssemblyThreading(), "wasm-threading is not enabled");
>+        uint8_t extOp;
>+        WASM_PARSER_FAIL_IF(!parseUInt8(extOp), "can't parse atomic extended opcode");
>+
>+        ExtAtomicOpType op = static_cast<ExtAtomicOpType>(extOp);
>+        switch (op) {
>+#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicLoad(op, memoryType);
>+        FOR_EACH_WASM_EXT_ATOMIC_LOAD_OP(CREATE_CASE)
>+#undef CREATE_CASE
>+#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicStore(op, memoryType);
>+        FOR_EACH_WASM_EXT_ATOMIC_STORE_OP(CREATE_CASE)
>+#undef CREATE_CASE
>+#define CREATE_CASE(name, id, b3op, inc, memoryType) case ExtAtomicOpType::name: return atomicBinaryRMW(op, memoryType);
>+        FOR_EACH_WASM_EXT_ATOMIC_BINARY_RMW_OP(CREATE_CASE)
>+#undef CREATE_CASE
>+        case ExtAtomicOpType::MemoryAtomicWait64:
>+            return atomicWait(op, I64);
>+        case ExtAtomicOpType::MemoryAtomicWait32:
>+            return atomicWait(op, I32);
>+        case ExtAtomicOpType::MemoryAtomicNotify:
>+            return atomicNotify(op);
>+        case ExtAtomicOpType::I32AtomicRmw8CmpxchgU:
>+        case ExtAtomicOpType::I32AtomicRmw16CmpxchgU:
>+        case ExtAtomicOpType::I32AtomicRmwCmpxchg:
>+            return atomicCompareExchange(op, I32);
>+        case ExtAtomicOpType::I64AtomicRmw8CmpxchgU:
>+        case ExtAtomicOpType::I64AtomicRmw16CmpxchgU:
>+        case ExtAtomicOpType::I64AtomicRmw32CmpxchgU:
>+        case ExtAtomicOpType::I64AtomicRmwCmpxchg:
>+            return atomicCompareExchange(op, I64);
>+        default:
>+            WASM_PARSER_FAIL_IF(true, "invalid extended atomic op ", extOp);
>+            break;
>+        }
>+        return { };
>+    }
>+
>     case RefNull: {
>         WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");
>         Type typeOfNull;
>@@ -1012,6 +1202,35 @@ auto FunctionParser<Context>::parseUnreachableExpression() -> PartialResult
>         return { };
>     }
> 
>+#define CREATE_ATOMIC_CASE(name, ...) case ExtAtomicOpType::name:
>+    case ExtAtomic: {
>+        WASM_PARSER_FAIL_IF(!Options::useWebAssemblyThreading(), "wasm-threading is not enabled");
>+        uint8_t extOp;
>+        WASM_PARSER_FAIL_IF(!parseUInt8(extOp), "can't parse atomic extended opcode");
>+        ExtAtomicOpType op = static_cast<ExtAtomicOpType>(extOp);
>+        switch (op) {
>+        FOR_EACH_WASM_EXT_ATOMIC_LOAD_OP(CREATE_ATOMIC_CASE)
>+        FOR_EACH_WASM_EXT_ATOMIC_STORE_OP(CREATE_ATOMIC_CASE)
>+        FOR_EACH_WASM_EXT_ATOMIC_BINARY_RMW_OP(CREATE_ATOMIC_CASE)
>+        FOR_EACH_WASM_EXT_ATOMIC_OTHER_OP(CREATE_ATOMIC_CASE)
>+        {
>+            WASM_VALIDATOR_FAIL_IF(!m_info.memory, "atomic instruction without memory");
>+            uint32_t alignment;
>+            uint32_t unused;
>+            WASM_PARSER_FAIL_IF(!parseVarUInt32(alignment), "can't get load alignment");
>+            WASM_PARSER_FAIL_IF(alignment > memoryLog2Alignment(op), "byte alignment ", 1ull << alignment, " exceeds load's natural alignment ", 1ull << memoryLog2Alignment(op));
>+            WASM_PARSER_FAIL_IF(!parseVarUInt32(unused), "can't get first immediate for atomic ", static_cast<unsigned>(op), " in unreachable context");
>+            break;
>+        }
>+        default:
>+            WASM_PARSER_FAIL_IF(true, "invalid extended atomic op ", extOp);
>+            break;
>+        }
>+
>+        return { };
>+    }
>+#undef CREATE_ATOMIC_CASE
>+
>     // no immediate cases
>     FOR_EACH_WASM_BINARY_OP(CREATE_CASE)
>     FOR_EACH_WASM_UNARY_OP(CREATE_CASE)
>diff --git a/Source/JavaScriptCore/wasm/WasmLLIntGenerator.cpp b/Source/JavaScriptCore/wasm/WasmLLIntGenerator.cpp
>index d3a059a99047a7317406d8bbac745726fcd242fd..cfdd7d04bc6134a79943fbd0bc7179e2eb9d9c0c 100644
>--- a/Source/JavaScriptCore/wasm/WasmLLIntGenerator.cpp
>+++ b/Source/JavaScriptCore/wasm/WasmLLIntGenerator.cpp
>@@ -209,6 +209,14 @@ class LLIntGenerator : public BytecodeGeneratorBase<GeneratorTraits> {
>     PartialResult WARN_UNUSED_RETURN addGrowMemory(ExpressionType delta, ExpressionType& result);
>     PartialResult WARN_UNUSED_RETURN addCurrentMemory(ExpressionType& result);
> 
>+    // Atomics
>+    PartialResult WARN_UNUSED_RETURN atomicLoad(ExtAtomicOpType, ExpressionType pointer, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicStore(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicBinaryRMW(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicCompareExchange(ExtAtomicOpType, ExpressionType pointer, ExpressionType expected, ExpressionType value, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicWait(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType timeout, ExpressionType& result, uint32_t offset);
>+    PartialResult WARN_UNUSED_RETURN atomicNotify(ExtAtomicOpType, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset);
>+
>     // Basic operators
>     template<OpType>
>     PartialResult WARN_UNUSED_RETURN addOp(ExpressionType arg, ExpressionType& result);
>@@ -1240,6 +1248,267 @@ auto LLIntGenerator::store(StoreOpType op, ExpressionType pointer, ExpressionTyp
>     return { };
> }
> 
>+auto LLIntGenerator::atomicLoad(ExtAtomicOpType op, ExpressionType pointer, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    result = push();
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicLoad8U:
>+        WasmI32AtomicRmw8AddU::emit(this, result, pointer, offset, zeroConstant());
>+        break;
>+    case ExtAtomicOpType::I64AtomicLoad8U:
>+        WasmI64AtomicRmw8AddU::emit(this, result, pointer, offset, zeroConstant());
>+        break;
>+    case ExtAtomicOpType::I32AtomicLoad16U:
>+        WasmI32AtomicRmw16AddU::emit(this, result, pointer, offset, zeroConstant());
>+        break;
>+    case ExtAtomicOpType::I64AtomicLoad16U:
>+        WasmI64AtomicRmw16AddU::emit(this, result, pointer, offset, zeroConstant());
>+        break;
>+    case ExtAtomicOpType::I32AtomicLoad:
>+        WasmI32AtomicRmwAdd::emit(this, result, pointer, offset, zeroConstant());
>+        break;
>+    case ExtAtomicOpType::I64AtomicLoad32U:
>+        WasmI64AtomicRmw32AddU::emit(this, result, pointer, offset, zeroConstant());
>+        break;
>+    case ExtAtomicOpType::I64AtomicLoad:
>+        WasmI64AtomicRmwAdd::emit(this, result, pointer, offset, zeroConstant());
>+        break;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+    }
>+
>+    return { };
>+}
>+
>+auto LLIntGenerator::atomicStore(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, uint32_t offset) -> PartialResult
>+{
>+    auto result = push();
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicStore8U:
>+        WasmI32AtomicRmw8XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicStore8U:
>+        WasmI64AtomicRmw8XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicStore16U:
>+        WasmI32AtomicRmw16XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicStore16U:
>+        WasmI64AtomicRmw16XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicStore:
>+        WasmI32AtomicRmwXchg::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicStore32U:
>+        WasmI64AtomicRmw32XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicStore:
>+        WasmI64AtomicRmwXchg::emit(this, result, pointer, offset, value);
>+        break;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+    }
>+
>+    didPopValueFromStack(); // Ignore the result.
>+    return { };
>+}
>+
>+auto LLIntGenerator::atomicBinaryRMW(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    result = push();
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicRmw8AddU:
>+        WasmI32AtomicRmw8AddU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw16AddU:
>+        WasmI32AtomicRmw16AddU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmwAdd:
>+        WasmI32AtomicRmwAdd::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw8AddU:
>+        WasmI64AtomicRmw8AddU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw16AddU:
>+        WasmI64AtomicRmw16AddU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw32AddU:
>+        WasmI64AtomicRmw32AddU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmwAdd:
>+        WasmI64AtomicRmwAdd::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8SubU:
>+        WasmI32AtomicRmw8SubU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw16SubU:
>+        WasmI32AtomicRmw16SubU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmwSub:
>+        WasmI32AtomicRmwSub::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw8SubU:
>+        WasmI64AtomicRmw8SubU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw16SubU:
>+        WasmI64AtomicRmw16SubU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw32SubU:
>+        WasmI64AtomicRmw32SubU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmwSub:
>+        WasmI64AtomicRmwSub::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8AndU:
>+        WasmI32AtomicRmw8AndU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw16AndU:
>+        WasmI32AtomicRmw16AndU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmwAnd:
>+        WasmI32AtomicRmwAnd::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw8AndU:
>+        WasmI64AtomicRmw8AndU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw16AndU:
>+        WasmI64AtomicRmw16AndU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw32AndU:
>+        WasmI64AtomicRmw32AndU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmwAnd:
>+        WasmI64AtomicRmwAnd::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8OrU:
>+        WasmI32AtomicRmw8OrU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw16OrU:
>+        WasmI32AtomicRmw16OrU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmwOr:
>+        WasmI32AtomicRmwOr::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw8OrU:
>+        WasmI64AtomicRmw8OrU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw16OrU:
>+        WasmI64AtomicRmw16OrU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw32OrU:
>+        WasmI64AtomicRmw32OrU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmwOr:
>+        WasmI64AtomicRmwOr::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8XorU:
>+        WasmI32AtomicRmw8XorU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw16XorU:
>+        WasmI32AtomicRmw16XorU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmwXor:
>+        WasmI32AtomicRmwXor::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw8XorU:
>+        WasmI64AtomicRmw8XorU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw16XorU:
>+        WasmI64AtomicRmw16XorU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw32XorU:
>+        WasmI64AtomicRmw32XorU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmwXor:
>+        WasmI64AtomicRmwXor::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw8XchgU:
>+        WasmI32AtomicRmw8XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw16XchgU:
>+        WasmI32AtomicRmw16XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmwXchg:
>+        WasmI32AtomicRmwXchg::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw8XchgU:
>+        WasmI64AtomicRmw8XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw16XchgU:
>+        WasmI64AtomicRmw16XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw32XchgU:
>+        WasmI64AtomicRmw32XchgU::emit(this, result, pointer, offset, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmwXchg:
>+        WasmI64AtomicRmwXchg::emit(this, result, pointer, offset, value);
>+        break;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        break;
>+    }
>+
>+    return { };
>+}
>+
>+auto LLIntGenerator::atomicCompareExchange(ExtAtomicOpType op, ExpressionType pointer, ExpressionType expected, ExpressionType value, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    result = push();
>+    switch (op) {
>+    case ExtAtomicOpType::I32AtomicRmw8CmpxchgU:
>+        WasmI32AtomicRmw8CmpxchgU::emit(this, result, pointer, offset, expected, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmw16CmpxchgU:
>+        WasmI32AtomicRmw16CmpxchgU::emit(this, result, pointer, offset, expected, value);
>+        break;
>+    case ExtAtomicOpType::I32AtomicRmwCmpxchg:
>+        WasmI32AtomicRmwCmpxchg::emit(this, result, pointer, offset, expected, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw8CmpxchgU:
>+        WasmI64AtomicRmw8CmpxchgU::emit(this, result, pointer, offset, expected, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw16CmpxchgU:
>+        WasmI64AtomicRmw16CmpxchgU::emit(this, result, pointer, offset, expected, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmw32CmpxchgU:
>+        WasmI64AtomicRmw32CmpxchgU::emit(this, result, pointer, offset, expected, value);
>+        break;
>+    case ExtAtomicOpType::I64AtomicRmwCmpxchg:
>+        WasmI64AtomicRmwCmpxchg::emit(this, result, pointer, offset, expected, value);
>+        break;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        break;
>+    }
>+
>+    return { };
>+}
>+
>+auto LLIntGenerator::atomicWait(ExtAtomicOpType op, ExpressionType pointer, ExpressionType value, ExpressionType timeout, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    result = push();
>+    switch (op) {
>+    case ExtAtomicOpType::MemoryAtomicWait32:
>+        WasmMemoryAtomicWait32::emit(this, result, pointer, offset, value, timeout);
>+        break;
>+    case ExtAtomicOpType::MemoryAtomicWait64:
>+        WasmMemoryAtomicWait64::emit(this, result, pointer, offset, value, timeout);
>+        break;
>+    default:
>+        RELEASE_ASSERT_NOT_REACHED();
>+        break;
>+    }
>+    return { };
>+}
>+
>+auto LLIntGenerator::atomicNotify(ExtAtomicOpType op, ExpressionType pointer, ExpressionType count, ExpressionType& result, uint32_t offset) -> PartialResult
>+{
>+    result = push();
>+    RELEASE_ASSERT(op == ExtAtomicOpType::MemoryAtomicNotify);
>+    WasmMemoryAtomicNotify::emit(this, result, pointer, offset, count);
>+    return { };
>+}
>+
> void LLIntGenerator::linkSwitchTargets(Label& label, unsigned location)
> {
>     auto it = m_switches.find(&label);
>diff --git a/Source/JavaScriptCore/wasm/WasmMemory.h b/Source/JavaScriptCore/wasm/WasmMemory.h
>index 4cebece9891fc2179934e3b67536ead9bde9c487..66cb18c022b96080b8573c5d30abf90f87062262 100644
>--- a/Source/JavaScriptCore/wasm/WasmMemory.h
>+++ b/Source/JavaScriptCore/wasm/WasmMemory.h
>@@ -61,6 +61,12 @@ class MemoryHandle final : public ThreadSafeRefCounted<MemoryHandle> {
>     void* memory() const;
>     size_t size() const { return m_size; }
>     size_t mappedCapacity() const { return m_mappedCapacity; }
>+    size_t boundsCheckingSize() const
>+    {
>+        if (m_mode == MemoryMode::BoundsChecking)
>+            return m_mappedCapacity;
>+        return UINT32_MAX;
>+    }
>     PageCount initial() const { return m_initial; }
>     PageCount maximum() const { return m_maximum; }
>     MemorySharingMode sharingMode() const { return m_sharingMode; }
>@@ -111,7 +117,7 @@ class Memory final : public RefCounted<Memory> {
>     void* memory() const { return m_handle->memory(); }
>     size_t size() const { return m_handle->size(); }
>     PageCount sizeInPages() const { return PageCount::fromBytes(size()); }
>-    size_t boundsCheckingSize() const { return m_handle->mappedCapacity(); }
>+    size_t boundsCheckingSize() const { return m_handle->boundsCheckingSize(); }
>     PageCount initial() const { return m_handle->initial(); }
>     PageCount maximum() const { return m_handle->maximum(); }
>     MemoryHandle& handle() { return m_handle.get(); }
>diff --git a/Source/JavaScriptCore/wasm/WasmMemoryInformation.cpp b/Source/JavaScriptCore/wasm/WasmMemoryInformation.cpp
>index f2c6fa508988c0c4908037183216871e8540cfe1..2652de72ed5658b77cee29912a529ef7f2bfb40d 100644
>--- a/Source/JavaScriptCore/wasm/WasmMemoryInformation.cpp
>+++ b/Source/JavaScriptCore/wasm/WasmMemoryInformation.cpp
>@@ -60,9 +60,10 @@ PinnedRegisterInfo::PinnedRegisterInfo(GPRReg boundsCheckingSizeRegister, GPRReg
> {
> }
> 
>-MemoryInformation::MemoryInformation(PageCount initial, PageCount maximum, bool isImport)
>+MemoryInformation::MemoryInformation(PageCount initial, PageCount maximum, bool isShared, bool isImport)
>     : m_initial(initial)
>     , m_maximum(maximum)
>+    , m_isShared(isShared)
>     , m_isImport(isImport)
> {
>     RELEASE_ASSERT(!!m_initial);
>diff --git a/Source/JavaScriptCore/wasm/WasmMemoryInformation.h b/Source/JavaScriptCore/wasm/WasmMemoryInformation.h
>index 23a86530bae10fdf7e0d42e35ab9077bb73df65f..854fba54e337f0f0248e339378443b341e0f7309 100644
>--- a/Source/JavaScriptCore/wasm/WasmMemoryInformation.h
>+++ b/Source/JavaScriptCore/wasm/WasmMemoryInformation.h
>@@ -72,10 +72,11 @@ class MemoryInformation {
>         ASSERT(!*this);
>     }
> 
>-    MemoryInformation(PageCount initial, PageCount maximum, bool isImport);
>+    MemoryInformation(PageCount initial, PageCount maximum, bool isShared, bool isImport);
> 
>     PageCount initial() const { return m_initial; }
>     PageCount maximum() const { return m_maximum; }
>+    bool isShared() const { return m_isShared; }
>     bool isImport() const { return m_isImport; }
> 
>     explicit operator bool() const { return !!m_initial; }
>@@ -83,6 +84,7 @@ class MemoryInformation {
> private:
>     PageCount m_initial { };
>     PageCount m_maximum { };
>+    bool m_isShared { false };
>     bool m_isImport { false };
> };
> 
>diff --git a/Source/JavaScriptCore/wasm/WasmOperations.cpp b/Source/JavaScriptCore/wasm/WasmOperations.cpp
>index f09b910e761a59bbee9af26150644fbad3acd6c3..2b369e7c70e47879b90530f8247c09e7bd1ebff6 100644
>--- a/Source/JavaScriptCore/wasm/WasmOperations.cpp
>+++ b/Source/JavaScriptCore/wasm/WasmOperations.cpp
>@@ -38,6 +38,8 @@
> #include "JSWebAssemblyInstance.h"
> #include "JSWebAssemblyRuntimeError.h"
> #include "ProbeContext.h"
>+#include "ReleaseHeapAccessScope.h"
>+#include "TypedArrayController.h"
> #include "WasmCallee.h"
> #include "WasmCallingConvention.h"
> #include "WasmContextInlines.h"
>@@ -732,6 +734,88 @@ JSC_DEFINE_JIT_OPERATION(operationGetWasmTableSize, int32_t, (Instance* instance
>     return instance->table(tableIndex)->length();
> }
> 
>+template<typename ValueType>
>+static int32_t wait(VM& vm, ValueType* pointer, ValueType expectedValue, int64_t timeoutInNanoseconds)
>+{
>+    Seconds timeout = Seconds::infinity();
>+    if (timeoutInNanoseconds >= 0) {
>+        int64_t timeoutInMilliseconds = timeoutInNanoseconds / 1000;
>+        timeout = Seconds::fromMilliseconds(timeoutInMilliseconds);
>+    }
>+    bool didPassValidation = false;
>+    ParkingLot::ParkResult result;
>+    {
>+        ReleaseHeapAccessScope releaseHeapAccessScope(vm.heap);
>+        result = ParkingLot::parkConditionally(
>+            pointer,
>+            [&] () -> bool {
>+                didPassValidation = WTF::atomicLoad(pointer) == expectedValue;
>+                return didPassValidation;
>+            },
>+            [] () { },
>+            MonotonicTime::now() + timeout);
>+    }
>+    if (!didPassValidation)
>+        return 1;
>+    if (!result.wasUnparked)
>+        return 2;
>+    return 0;
>+}
>+
>+JSC_DEFINE_JIT_OPERATION(operationMemoryAtomicWait32, int32_t, (Instance* instance, unsigned base, unsigned offset, uint32_t value, int64_t timeoutInNanoseconds))
>+{
>+    VM& vm = instance->owner<JSWebAssemblyInstance>()->vm();
>+    unsigned offsetInMemory = base + offset;
>+    if (offsetInMemory & (0x4 - 1))
>+        return -1;
>+    if (!instance->memory())
>+        return -1;
>+    if (offsetInMemory >= instance->memory()->size())
>+        return -1;
>+    if (instance->memory()->sharingMode() != MemorySharingMode::Shared)
>+        return -1;
>+    if (!vm.m_typedArrayController->isAtomicsWaitAllowedOnCurrentThread())
>+        return -1;
>+    uint32_t* pointer = bitwise_cast<uint32_t*>(instance->memory()->memory()) + offsetInMemory;
>+    return wait<uint32_t>(vm, pointer, value, timeoutInNanoseconds);
>+}
>+
>+JSC_DEFINE_JIT_OPERATION(operationMemoryAtomicWait64, int32_t, (Instance* instance, unsigned base, unsigned offset, uint64_t value, int64_t timeoutInNanoseconds))
>+{
>+    VM& vm = instance->owner<JSWebAssemblyInstance>()->vm();
>+    unsigned offsetInMemory = base + offset;
>+    if (offsetInMemory & (0x8 - 1))
>+        return -1;
>+    if (!instance->memory())
>+        return -1;
>+    if (offsetInMemory >= instance->memory()->size())
>+        return -1;
>+    if (instance->memory()->sharingMode() != MemorySharingMode::Shared)
>+        return -1;
>+    if (!vm.m_typedArrayController->isAtomicsWaitAllowedOnCurrentThread())
>+        return -1;
>+    uint64_t* pointer = bitwise_cast<uint64_t*>(instance->memory()->memory()) + offsetInMemory;
>+    return wait<uint64_t>(vm, pointer, value, timeoutInNanoseconds);
>+}
>+
>+JSC_DEFINE_JIT_OPERATION(operationMemoryAtomicNotify, int32_t, (Instance* instance, unsigned base, unsigned offset, int32_t countValue))
>+{
>+    unsigned offsetInMemory = base + offset;
>+    if (offsetInMemory & (0x4 - 1))
>+        return -1;
>+    if (!instance->memory())
>+        return -1;
>+    if (offsetInMemory >= instance->memory()->size())
>+        return -1;
>+    if (instance->memory()->sharingMode() != MemorySharingMode::Shared)
>+        return 0;
>+    uint8_t* pointer = bitwise_cast<uint8_t*>(instance->memory()->memory()) + offsetInMemory;
>+    unsigned count = UINT_MAX;
>+    if (countValue >= 0)
>+        count = static_cast<unsigned>(countValue);
>+    return ParkingLot::unparkCount(pointer, count);
>+}
>+
> JSC_DEFINE_JIT_OPERATION(operationWasmToJSException, void*, (CallFrame* callFrame, Wasm::ExceptionType type, Instance* wasmInstance))
> {
>     wasmInstance->storeTopCallFrame(callFrame);
>diff --git a/Source/JavaScriptCore/wasm/WasmOperations.h b/Source/JavaScriptCore/wasm/WasmOperations.h
>index 81917a2ebac30ed75a49c7375d02462afe1cd5fc..302dd0e6c3a1665d1306ff16ffbfdef38b8f3199 100644
>--- a/Source/JavaScriptCore/wasm/WasmOperations.h
>+++ b/Source/JavaScriptCore/wasm/WasmOperations.h
>@@ -69,6 +69,10 @@ JSC_DECLARE_JIT_OPERATION(operationWasmTableGrow, int32_t, (Instance*, unsigned,
> JSC_DECLARE_JIT_OPERATION(operationWasmTableFill, bool, (Instance*, unsigned, int32_t offset, EncodedJSValue fill, int32_t count));
> JSC_DECLARE_JIT_OPERATION(operationGetWasmTableSize, int32_t, (Instance*, unsigned));
> 
>+JSC_DECLARE_JIT_OPERATION(operationMemoryAtomicWait32, int32_t, (Instance* instance, unsigned base, unsigned offset, uint32_t value, int64_t timeout));
>+JSC_DECLARE_JIT_OPERATION(operationMemoryAtomicWait64, int32_t, (Instance* instance, unsigned base, unsigned offset, uint64_t value, int64_t timeout));
>+JSC_DECLARE_JIT_OPERATION(operationMemoryAtomicNotify, int32_t, (Instance*, unsigned, unsigned, int32_t));
>+
> JSC_DECLARE_JIT_OPERATION(operationWasmToJSException, void*, (CallFrame*, Wasm::ExceptionType, Instance*));
> 
> } } // namespace JSC::Wasm
>diff --git a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp b/Source/JavaScriptCore/wasm/WasmSectionParser.cpp
>index b83cf34076a7f2bfcf11b89de4f4b1f0308c85e6..83b767099370f5c5110fe62b42e8ca315d6624d6 100644
>--- a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp
>+++ b/Source/JavaScriptCore/wasm/WasmSectionParser.cpp
>@@ -177,14 +177,16 @@ auto SectionParser::parseFunction() -> PartialResult
>     return { };
> }
> 
>-auto SectionParser::parseResizableLimits(uint32_t& initial, Optional<uint32_t>& maximum) -> PartialResult
>+auto SectionParser::parseResizableLimits(uint32_t& initial, Optional<uint32_t>& maximum, bool& isShared, LimitsType limitsType) -> PartialResult
> {
>     ASSERT(!maximum);
> 
>     uint8_t flags;
>     WASM_PARSER_FAIL_IF(!parseUInt8(flags), "can't parse resizable limits flags");
>-    WASM_PARSER_FAIL_IF(flags != 0x0 && flags != 0x1, "resizable limits flag should be 0x00 or 0x01 but 0x", hex(flags, 2, Lowercase));
>+    WASM_PARSER_FAIL_IF(flags != 0x0 && flags != 0x1 && flags != 0x3, "resizable limits flag should be 0x00, 0x01, or 0x03 but 0x", hex(flags, 2, Lowercase));
>+    WASM_PARSER_FAIL_IF(flags == 0x3 && limitsType != LimitsType::Memory, "can't use shared limits for non memory");
>     WASM_PARSER_FAIL_IF(!parseVarUInt32(initial), "can't parse resizable limits initial page count");
>+    isShared = flags == 0x3;
> 
>     if (flags) {
>         uint32_t maximumInt;
>@@ -206,7 +208,8 @@ auto SectionParser::parseTableHelper(bool isImport) -> PartialResult
> 
>     uint32_t initial;
>     Optional<uint32_t> maximum;
>-    PartialResult limits = parseResizableLimits(initial, maximum);
>+    bool isShared = false;
>+    PartialResult limits = parseResizableLimits(initial, maximum, isShared, LimitsType::Table);
>     if (UNLIKELY(!limits))
>         return makeUnexpected(WTFMove(limits.error()));
>     WASM_PARSER_FAIL_IF(initial > maxTableEntries, "Table's initial page count of ", initial, " is too big, maximum ", maxTableEntries);
>@@ -240,10 +243,11 @@ auto SectionParser::parseMemoryHelper(bool isImport) -> PartialResult
> 
>     PageCount initialPageCount;
>     PageCount maximumPageCount;
>+    bool isShared = false;
>     {
>         uint32_t initial;
>         Optional<uint32_t> maximum;
>-        PartialResult limits = parseResizableLimits(initial, maximum);
>+        PartialResult limits = parseResizableLimits(initial, maximum, isShared, LimitsType::Memory);
>         if (UNLIKELY(!limits))
>             return makeUnexpected(WTFMove(limits.error()));
>         ASSERT(!maximum || *maximum >= initial);
>@@ -259,7 +263,7 @@ auto SectionParser::parseMemoryHelper(bool isImport) -> PartialResult
>     ASSERT(initialPageCount);
>     ASSERT(!maximumPageCount || maximumPageCount >= initialPageCount);
> 
>-    m_info->memory = MemoryInformation(initialPageCount, maximumPageCount, isImport);
>+    m_info->memory = MemoryInformation(initialPageCount, maximumPageCount, isShared, isImport);
>     return { };
> }
> 
>diff --git a/Source/JavaScriptCore/wasm/WasmSectionParser.h b/Source/JavaScriptCore/wasm/WasmSectionParser.h
>index 5277a7ac0fe9090a006a480f0f4a7502a26b0c94..86b980ac068e3f783ad85fdcdceeb128de5dfcd3 100644
>--- a/Source/JavaScriptCore/wasm/WasmSectionParser.h
>+++ b/Source/JavaScriptCore/wasm/WasmSectionParser.h
>@@ -63,7 +63,8 @@ class SectionParser final : public Parser<void> {
>     PartialResult WARN_UNUSED_RETURN parseGlobalType(GlobalInformation&);
>     PartialResult WARN_UNUSED_RETURN parseMemoryHelper(bool isImport);
>     PartialResult WARN_UNUSED_RETURN parseTableHelper(bool isImport);
>-    PartialResult WARN_UNUSED_RETURN parseResizableLimits(uint32_t& initial, Optional<uint32_t>& maximum);
>+    enum class LimitsType { Memory, Table };
>+    PartialResult WARN_UNUSED_RETURN parseResizableLimits(uint32_t& initial, Optional<uint32_t>& maximum, bool& isShared, LimitsType);
>     PartialResult WARN_UNUSED_RETURN parseInitExpr(uint8_t&, uint64_t&, Type& initExprType);
> 
>     size_t m_offsetInSource;
>diff --git a/Source/JavaScriptCore/wasm/WasmSlowPaths.cpp b/Source/JavaScriptCore/wasm/WasmSlowPaths.cpp
>index 90621121a81e31b52175b597d9bc41264867633a..e0e4f16872001e7c4b18478a2bc8167fef97bdfc 100644
>--- a/Source/JavaScriptCore/wasm/WasmSlowPaths.cpp
>+++ b/Source/JavaScriptCore/wasm/WasmSlowPaths.cpp
>@@ -438,6 +438,44 @@ WASM_SLOW_PATH_DECL(set_global_ref_portable_binding)
>     WASM_END_IMPL();
> }
> 
>+WASM_SLOW_PATH_DECL(memory_atomic_wait32)
>+{
>+    auto instruction = pc->as<WasmMemoryAtomicWait32, WasmOpcodeTraits>();
>+    unsigned base = READ(instruction.m_pointer).unboxedInt32();
>+    unsigned offset = instruction.m_offset;
>+    uint32_t value = READ(instruction.m_value).unboxedInt32();
>+    int64_t timeout = READ(instruction.m_timeout).unboxedInt64();
>+    int32_t result = Wasm::operationMemoryAtomicWait32(instance, base, offset, value, timeout);
>+    if (result < 0)
>+        WASM_THROW(Wasm::ExceptionType::OutOfBoundsMemoryAccess);
>+    WASM_RETURN(result);
>+}
>+
>+WASM_SLOW_PATH_DECL(memory_atomic_wait64)
>+{
>+    auto instruction = pc->as<WasmMemoryAtomicWait64, WasmOpcodeTraits>();
>+    unsigned base = READ(instruction.m_pointer).unboxedInt32();
>+    unsigned offset = instruction.m_offset;
>+    uint64_t value = READ(instruction.m_value).unboxedInt64();
>+    int64_t timeout = READ(instruction.m_timeout).unboxedInt64();
>+    int32_t result = Wasm::operationMemoryAtomicWait64(instance, base, offset, value, timeout);
>+    if (result < 0)
>+        WASM_THROW(Wasm::ExceptionType::OutOfBoundsMemoryAccess);
>+    WASM_RETURN(result);
>+}
>+
>+WASM_SLOW_PATH_DECL(memory_atomic_notify)
>+{
>+    auto instruction = pc->as<WasmMemoryAtomicNotify, WasmOpcodeTraits>();
>+    unsigned base = READ(instruction.m_pointer).unboxedInt32();
>+    unsigned offset = instruction.m_offset;
>+    int32_t count = READ(instruction.m_count).unboxedInt32();
>+    int32_t result = Wasm::operationMemoryAtomicNotify(instance, base, offset, count);
>+    if (result < 0)
>+        WASM_THROW(Wasm::ExceptionType::OutOfBoundsMemoryAccess);
>+    WASM_RETURN(result);
>+}
>+
> extern "C" SlowPathReturnType slow_path_wasm_throw_exception(CallFrame* callFrame, const Instruction* pc, Wasm::Instance* instance, Wasm::ExceptionType exceptionType)
> {
>     UNUSED_PARAM(pc);
>diff --git a/Source/JavaScriptCore/wasm/WasmSlowPaths.h b/Source/JavaScriptCore/wasm/WasmSlowPaths.h
>index 5540a0753f0c6e77d10729c8ca54d69352c4581b..5f6c48424fecbf4083bfec3326dda768dcb9a607 100644
>--- a/Source/JavaScriptCore/wasm/WasmSlowPaths.h
>+++ b/Source/JavaScriptCore/wasm/WasmSlowPaths.h
>@@ -69,6 +69,9 @@ WASM_SLOW_PATH_HIDDEN_DECL(call_indirect);
> WASM_SLOW_PATH_HIDDEN_DECL(call_indirect_no_tls);
> WASM_SLOW_PATH_HIDDEN_DECL(set_global_ref);
> WASM_SLOW_PATH_HIDDEN_DECL(set_global_ref_portable_binding);
>+WASM_SLOW_PATH_HIDDEN_DECL(memory_atomic_wait32);
>+WASM_SLOW_PATH_HIDDEN_DECL(memory_atomic_wait64);
>+WASM_SLOW_PATH_HIDDEN_DECL(memory_atomic_notify);
> 
> extern "C" SlowPathReturnType slow_path_wasm_throw_exception(CallFrame*, const Instruction*, Wasm::Instance* instance, Wasm::ExceptionType) WTF_INTERNAL;
> extern "C" SlowPathReturnType slow_path_wasm_popcount(const Instruction* pc, uint32_t) WTF_INTERNAL;
>diff --git a/Source/JavaScriptCore/wasm/generateWasm.py b/Source/JavaScriptCore/wasm/generateWasm.py
>index e5a0a20a4a586c201916720fddbccac63482f8b4..9853e16aed71c2c380968bff3dff3a4f6d4914c9 100755
>--- a/Source/JavaScriptCore/wasm/generateWasm.py
>+++ b/Source/JavaScriptCore/wasm/generateWasm.py
>@@ -93,13 +93,43 @@ def isBinary(op):
>     return isNormal(op) and len(op["parameter"]) == 2
> 
> 
>+def isAtomic(op):
>+    return op["category"].startswith("atomic")
>+
>+
>+def isAtomicLoad(op):
>+    return op["category"] == "atomic.load"
>+
>+
>+def isAtomicStore(op):
>+    return op["category"] == "atomic.store"
>+
>+
>+def isAtomicBinaryRMW(op):
>+    return op["category"] == "atomic.rmw.binary"
>+
>+
> def isSimple(op):
>     return "b3op" in op
> 
> 
> def memoryLog2Alignment(op):
>-    assert op["opcode"]["category"] == "memory"
>-    match = re.match(r'^[if]([36][24])\.[^0-9]+([0-9]+)?_?[us]?$', op["name"])
>-    memoryBits = int(match.group(2) if match.group(2) else match.group(1))
>+    assert op["opcode"]["category"] == "memory" or op["opcode"]["category"] == "atomic.load" or op["opcode"]["category"] == "atomic.store" or op["opcode"]["category"] == "atomic.rmw" or op["opcode"]["category"] == "atomic" or op["opcode"]["category"] == "atomic.rmw.binary"
>+    if op["opcode"]["category"] == "atomic.rmw.binary" or op["opcode"]["category"] == "atomic.rmw":
>+        match = re.match(r'^[if]([36][24])\.[^0-9]+([0-9]+)?\.[^0-9]+_?[us]?$', op["name"])
>+        if not match:
>+            print(op["name"])
>+        memoryBits = int(match.group(2) if match.group(2) else match.group(1))
>+    elif op["opcode"]["category"] == "atomic":
>+        if op["name"] == "memory.atomic.notify":
>+            memoryBits = 32
>+        else:
>+            match = re.match(r'^memory\.atomic\.wait([0-9]+)$', op["name"])
>+            memoryBits = int(match.group(1))
>+    else:
>+        match = re.match(r'^[if]([36][24])\.[^0-9]+([0-9]+)?_?[us]?$', op["name"])
>+        if not match:
>+            print(op["name"])
>+        memoryBits = int(match.group(2) if match.group(2) else match.group(1))
>     assert 2 ** math.log(memoryBits, 2) == memoryBits
>     return str(int(math.log(memoryBits / 8, 2)))
>diff --git a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py b/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py
>index cb0281b9ac53bd9adde86c2c8b34be3a7d8ef738..3cd626c2790985178cb764f9bf0d2fd6e6c4458a 100755
>--- a/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py
>+++ b/Source/JavaScriptCore/wasm/generateWasmOpsHeader.py
>@@ -92,8 +92,26 @@ def modifier(op):
>     return opcodeMacroizer(lambda op: (op["category"] == "memory" and len(op["return"]) == 0), modifier=modifier)
> 
> 
>+def atomicMemoryLoadMacroizer():
>+    def modifier(op):
>+        return [cppType(op["return"][0])]
>+    return opcodeMacroizer(lambda op: isAtomicLoad(op), modifier=modifier, opcodeField="extendedOp")
>+
>+
>+def atomicMemoryStoreMacroizer():
>+    def modifier(op):
>+        return [cppType(op["parameter"][1])]
>+    return opcodeMacroizer(lambda op: isAtomicStore(op), modifier=modifier, opcodeField="extendedOp")
>+
>+
>+def atomicBinaryRMWMacroizer():
>+    def modifier(op):
>+        return [cppType(op["parameter"][1])]
>+    return opcodeMacroizer(lambda op: isAtomicBinaryRMW(op), modifier=modifier, opcodeField="extendedOp")
>+
>+
> defines = ["#define FOR_EACH_WASM_SPECIAL_OP(macro)"]
>-defines.extend([op for op in opcodeMacroizer(lambda op: not (isUnary(op) or isBinary(op) or op["category"] == "control" or op["category"] == "memory" or op["category"] == "exttable"))])
>+defines.extend([op for op in opcodeMacroizer(lambda op: not (isUnary(op) or isBinary(op) or op["category"] == "control" or op["category"] == "memory" or op["category"] == "exttable"or isAtomic(op)))])
> defines.append("\n\n#define FOR_EACH_WASM_CONTROL_FLOW_OP(macro)")
> defines.extend([op for op in opcodeMacroizer(lambda op: op["category"] == "control")])
> defines.append("\n\n#define FOR_EACH_WASM_SIMPLE_UNARY_OP(macro)")
>@@ -110,6 +128,14 @@ def modifier(op):
> defines.extend([op for op in memoryStoreMacroizer()])
> defines.append("\n\n#define FOR_EACH_WASM_EXT_TABLE_OP(macro)")
> defines.extend([op for op in opcodeMacroizer(lambda op: (op["category"] == "exttable"), opcodeField="extendedOp")])
>+defines.append("\n\n#define FOR_EACH_WASM_EXT_ATOMIC_LOAD_OP(macro)")
>+defines.extend([op for op in atomicMemoryLoadMacroizer()])
>+defines.append("\n\n#define FOR_EACH_WASM_EXT_ATOMIC_STORE_OP(macro)")
>+defines.extend([op for op in atomicMemoryStoreMacroizer()])
>+defines.append("\n\n#define FOR_EACH_WASM_EXT_ATOMIC_BINARY_RMW_OP(macro)")
>+defines.extend([op for op in atomicBinaryRMWMacroizer()])
>+defines.append("\n\n#define FOR_EACH_WASM_EXT_ATOMIC_OTHER_OP(macro)")
>+defines.extend([op for op in opcodeMacroizer(lambda op: isAtomic(op) and (not isAtomicLoad(op) and not isAtomicStore(op) and not isAtomicBinaryRMW(op)), opcodeField="extendedOp")])
> defines.append("\n\n")
> 
> defines = "".join(defines)
>@@ -142,9 +168,22 @@ def memoryLog2AlignmentGenerator(filter):
>         result.append("    case " + wasm.toCpp(op["name"]) + ": return " + memoryLog2Alignment(op) + ";")
>     return "\n".join(result)
> 
>+def atomicMemoryLog2AlignmentGenerator(filter):
>+    result = []
>+    for op in wasm.opcodeIterator(filter):
>+        result.append("    case ExtAtomicOpType::" + wasm.toCpp(op["name"]) + ": return " + memoryLog2Alignment(op) + ";")
>+    return "\n".join(result)
>+
>+
> memoryLog2AlignmentLoads = memoryLog2AlignmentGenerator(lambda op: (op["category"] == "memory" and len(op["return"]) == 1))
> memoryLog2AlignmentStores = memoryLog2AlignmentGenerator(lambda op: (op["category"] == "memory" and len(op["return"]) == 0))
> 
>+memoryLog2AlignmentAtomicLoads = atomicMemoryLog2AlignmentGenerator(lambda op: (op["category"] == "atomic.load"))
>+memoryLog2AlignmentAtomicStores = atomicMemoryLog2AlignmentGenerator(lambda op: (op["category"] == "atomic.store"))
>+memoryLog2AlignmentAtomicBinaryRMW = atomicMemoryLog2AlignmentGenerator(lambda op: (op["category"] == "atomic.rmw.binary"))
>+memoryLog2AlignmentAtomicOtherRMW = atomicMemoryLog2AlignmentGenerator(lambda op: (op["category"] == "atomic.rmw"))
>+memoryLog2AlignmentAtomicOther = atomicMemoryLog2AlignmentGenerator(lambda op: (op["category"] == "atomic"))
>+
> 
> contents = wasm.header + """
> 
>@@ -233,7 +272,8 @@ def memoryLog2AlignmentGenerator(filter):
>     FOR_EACH_WASM_BINARY_OP(macro) \\
>     FOR_EACH_WASM_MEMORY_LOAD_OP(macro) \\
>     FOR_EACH_WASM_MEMORY_STORE_OP(macro) \\
>-    macro(ExtTable, 0xFC, Oops, 0)
>+    macro(ExtTable,  0xFC, Oops, 0) \\
>+    macro(ExtAtomic, 0xFE, Oops, 0)
> 
> #define CREATE_ENUM_VALUE(name, id, ...) name = id,
> 
>@@ -269,6 +309,13 @@ def memoryLog2AlignmentGenerator(filter):
>     FOR_EACH_WASM_EXT_TABLE_OP(CREATE_ENUM_VALUE)
> };
> 
>+enum class ExtAtomicOpType : uint8_t {
>+    FOR_EACH_WASM_EXT_ATOMIC_LOAD_OP(CREATE_ENUM_VALUE)
>+    FOR_EACH_WASM_EXT_ATOMIC_STORE_OP(CREATE_ENUM_VALUE)
>+    FOR_EACH_WASM_EXT_ATOMIC_BINARY_RMW_OP(CREATE_ENUM_VALUE)
>+    FOR_EACH_WASM_EXT_ATOMIC_OTHER_OP(CREATE_ENUM_VALUE)
>+};
>+
> #undef CREATE_ENUM_VALUE
> 
> inline bool isControlOp(OpType op)
>@@ -322,6 +369,21 @@ def memoryLog2AlignmentGenerator(filter):
>     return 0;
> }
> 
>+inline uint32_t memoryLog2Alignment(ExtAtomicOpType op)
>+{
>+    switch (op) {
>+""" + memoryLog2AlignmentAtomicLoads + """
>+""" + memoryLog2AlignmentAtomicStores + """
>+""" + memoryLog2AlignmentAtomicBinaryRMW + """
>+""" + memoryLog2AlignmentAtomicOtherRMW + """
>+""" + memoryLog2AlignmentAtomicOther + """
>+    default:
>+        break;
>+    }
>+    RELEASE_ASSERT_NOT_REACHED();
>+    return 0;
>+}
>+
> #define CREATE_CASE(name, ...) case name: return #name;
> inline const char* makeString(OpType op)
> {
>diff --git a/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp b/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp
>index e49fc6925a995e5e0af59bef3e6020fbd403ba0a..56b99108978a2f4b33821d47723663b3f6028e53 100644
>--- a/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp
>+++ b/Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.cpp
>@@ -291,7 +291,7 @@ JSWebAssemblyInstance* JSWebAssemblyInstance::tryCreate(VM& vm, JSGlobalObject*
>             auto* jsMemory = JSWebAssemblyMemory::tryCreate(globalObject, vm, globalObject->webAssemblyMemoryStructure());
>             RETURN_IF_EXCEPTION(throwScope, nullptr);
> 
>-            RefPtr<Wasm::Memory> memory = Wasm::Memory::tryCreate(moduleInformation.memory.initial(), moduleInformation.memory.maximum(), Wasm::MemorySharingMode::Default,
>+            RefPtr<Wasm::Memory> memory = Wasm::Memory::tryCreate(moduleInformation.memory.initial(), moduleInformation.memory.maximum(), moduleInformation.memory.isShared() ? Wasm::MemorySharingMode::Shared: Wasm::MemorySharingMode::Default,
>                 [&vm] (Wasm::Memory::NotifyPressure) { vm.heap.collectAsync(CollectionScope::Full); },
>                 [&vm] (Wasm::Memory::SyncTryToReclaim) { vm.heap.collectSync(CollectionScope::Full); },
>                 [&vm, jsMemory] (Wasm::Memory::GrowSuccess, Wasm::PageCount oldPageCount, Wasm::PageCount newPageCount) { jsMemory->growSuccessCallback(vm, oldPageCount, newPageCount); });
>diff --git a/Source/JavaScriptCore/wasm/wasm.json b/Source/JavaScriptCore/wasm/wasm.json
>index 947344e150c114562933377e35d5a8e416d00c23..3b8d2ca15083fc88c5455c661162ca2d5f77c20b 100644
>--- a/Source/JavaScriptCore/wasm/wasm.json
>+++ b/Source/JavaScriptCore/wasm/wasm.json
>@@ -223,6 +223,73 @@
>         "i32.reinterpret/f32": { "category": "conversion", "value": 188, "return": ["i32"],                          "parameter": ["f32"],                        "immediate": [], "b3op": "BitwiseCast"  },
>         "i64.reinterpret/f64": { "category": "conversion", "value": 189, "return": ["i64"],                          "parameter": ["f64"],                        "immediate": [], "b3op": "BitwiseCast"  },
>         "i32.extend8_s":       { "category": "conversion", "value": 192, "return": ["i32"],                          "parameter": ["i32"],                        "immediate": [], "b3op": "SExt8"        },
>-        "i32.extend16_s":      { "category": "conversion", "value": 193, "return": ["i32"],                          "parameter": ["i32"],                        "immediate": [], "b3op": "SExt16"       }
>+        "i32.extend16_s":      { "category": "conversion", "value": 193, "return": ["i32"],                          "parameter": ["i32"],                        "immediate": [], "b3op": "SExt16"       },
>+
>+        "memory.atomic.notify":       { "category": "atomic",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp":  0 },
>+        "memory.atomic.wait32":       { "category": "atomic",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp":  1 },
>+        "memory.atomic.wait64":       { "category": "atomic",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp":  2 },
>+        "i32.atomic.load":            { "category": "atomic.load",     "value": 254, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 16 },
>+        "i64.atomic.load":            { "category": "atomic.load",     "value": 254, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 17 },
>+        "i32.atomic.load8_u":         { "category": "atomic.load",     "value": 254, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 18 },
>+        "i32.atomic.load16_u":        { "category": "atomic.load",     "value": 254, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 19 },
>+        "i64.atomic.load8_u":         { "category": "atomic.load",     "value": 254, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 20 },
>+        "i64.atomic.load16_u":        { "category": "atomic.load",     "value": 254, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 21 },
>+        "i64.atomic.load32_u":        { "category": "atomic.load",     "value": 254, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 22 },
>+        "i32.atomic.store":           { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 23 },
>+        "i64.atomic.store":           { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 24 },
>+        "i32.atomic.store8_u":        { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 25 },
>+        "i32.atomic.store16_u":       { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 26 },
>+        "i64.atomic.store8_u":        { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 27 },
>+        "i64.atomic.store16_u":       { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 28 },
>+        "i64.atomic.store32_u":       { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 29 },
>+        "i32.atomic.rmw.add":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 30 },
>+        "i64.atomic.rmw.add":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 31 },
>+        "i32.atomic.rmw8.add_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 32 },
>+        "i32.atomic.rmw16.add_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 33 },
>+        "i64.atomic.rmw8.add_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 34 },
>+        "i64.atomic.rmw16.add_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 35 },
>+        "i64.atomic.rmw32.add_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 36 },
>+        "i32.atomic.rmw.sub":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 37 },
>+        "i64.atomic.rmw.sub":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 38 },
>+        "i32.atomic.rmw8.sub_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 39 },
>+        "i32.atomic.rmw16.sub_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 40 },
>+        "i64.atomic.rmw8.sub_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 41 },
>+        "i64.atomic.rmw16.sub_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 42 },
>+        "i64.atomic.rmw32.sub_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 43 },
>+        "i32.atomic.rmw.and":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 44 },
>+        "i64.atomic.rmw.and":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 45 },
>+        "i32.atomic.rmw8.and_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 46 },
>+        "i32.atomic.rmw16.and_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 47 },
>+        "i64.atomic.rmw8.and_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 48 },
>+        "i64.atomic.rmw16.and_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 49 },
>+        "i64.atomic.rmw32.and_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 50 },
>+        "i32.atomic.rmw.or":          { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 51 },
>+        "i64.atomic.rmw.or":          { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 52 },
>+        "i32.atomic.rmw8.or_u":       { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 53 },
>+        "i32.atomic.rmw16.or_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 54 },
>+        "i64.atomic.rmw8.or_u":       { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 55 },
>+        "i64.atomic.rmw16.or_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 56 },
>+        "i64.atomic.rmw32.or_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 57 },
>+        "i32.atomic.rmw.xor":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 58 },
>+        "i64.atomic.rmw.xor":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 59 },
>+        "i32.atomic.rmw8.xor_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 60 },
>+        "i32.atomic.rmw16.xor_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 61 },
>+        "i64.atomic.rmw8.xor_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 62 },
>+        "i64.atomic.rmw16.xor_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 63 },
>+        "i64.atomic.rmw32.xor_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 64 },
>+        "i32.atomic.rmw.xchg":        { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 65 },
>+        "i64.atomic.rmw.xchg":        { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 66 },
>+        "i32.atomic.rmw8.xchg_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 67 },
>+        "i32.atomic.rmw16.xchg_u":    { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 68 },
>+        "i64.atomic.rmw8.xchg_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 69 },
>+        "i64.atomic.rmw16.xchg_u":    { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 70 },
>+        "i64.atomic.rmw32.xchg_u":    { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 71 },
>+        "i32.atomic.rmw.cmpxchg":     { "category": "atomic.rmw",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32", "i32"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 72 },
>+        "i64.atomic.rmw.cmpxchg":     { "category": "atomic.rmw",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 73 },
>+        "i32.atomic.rmw8.cmpxchg_u":  { "category": "atomic.rmw",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32", "i32"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 74 },
>+        "i32.atomic.rmw16.cmpxchg_u": { "category": "atomic.rmw",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32", "i32"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 75 },
>+        "i64.atomic.rmw8.cmpxchg_u":  { "category": "atomic.rmw",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 76 },
>+        "i64.atomic.rmw16.cmpxchg_u": { "category": "atomic.rmw",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 77 },
>+        "i64.atomic.rmw32.cmpxchg_u": { "category": "atomic.rmw",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 78 }
>     }
> }
>diff --git a/JSTests/ChangeLog b/JSTests/ChangeLog
>index 350ec3578f79625ac5a02281d199ec1bf7d899a9..87e9c023372a564db664946f025b22b67e385c28 100644
>--- a/JSTests/ChangeLog
>+++ b/JSTests/ChangeLog
>@@ -1,3 +1,16 @@
>+2020-11-20  Yusuke Suzuki  <ysuzuki@apple.com>
>+
>+        [JSC] Add wasm atomics instructions
>+        https://bugs.webkit.org/show_bug.cgi?id=218954
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * wasm.yaml:
>+        * wasm/spec-harness/sync_index.js:
>+        * wasm/threads-spec-tests/atomic.wast.js: Added.
>+        * wasm/threads-spec-tests/memory.wast.js: Added.
>+        * wasm/wasm.json:
>+
> 2020-11-17  Yusuke Suzuki  <ysuzuki@apple.com>
> 
>         [JSC] Improve Wasm binary test coverage
>diff --git a/JSTests/wasm.yaml b/JSTests/wasm.yaml
>index fd343dad29f423d187b65c0114e294608266cbe5..aed7fcd0989247f6ca66bf4b9699f8a62de9aad4 100644
>--- a/JSTests/wasm.yaml
>+++ b/JSTests/wasm.yaml
>@@ -65,6 +65,11 @@
> - path: wasm/multi-value-spec-tests/type.wast.js
>   cmd: runWebAssemblySpecTest :normal
> 
>+- path: wasm/threads-spec-tests/atomic.wast.js
>+  cmd: runWebAssemblySpecTest :normal
>+- path: wasm/threads-spec-tests/memory.wast.js
>+  cmd: runWebAssemblySpecTest :normal
>+
> - path: wasm/spec-tests/address.wast.js
>   cmd: runWebAssemblySpecTest :normal
> - path: wasm/spec-tests/align.wast.js
>diff --git a/JSTests/wasm/spec-harness/sync_index.js b/JSTests/wasm/spec-harness/sync_index.js
>index cbe89d1e925e9b06c10787f5638f02d16a28fc01..fdc4789a809d38658aaabbcdf283fba37338dc58 100644
>--- a/JSTests/wasm/spec-harness/sync_index.js
>+++ b/JSTests/wasm/spec-harness/sync_index.js
>@@ -179,6 +179,7 @@ function instance(bytes, imports = registry, valid = true) {
>         let m = module(bytes);
>         i = new WebAssembly.Instance(m, imports);
>     } catch(e) {
>+        print(String(e));
>         err = e;
>     }
> 
>diff --git a/JSTests/wasm/threads-spec-tests/atomic.wast.js b/JSTests/wasm/threads-spec-tests/atomic.wast.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..24783220c76e1944035486f5d1457425561647e2
>--- /dev/null
>+++ b/JSTests/wasm/threads-spec-tests/atomic.wast.js
>@@ -0,0 +1,891 @@
>+
>+// atomic.wast:3
>+let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\xb3\x80\x80\x80\x00\x09\x60\x01\x7e\x00\x60\x01\x7f\x01\x7f\x60\x01\x7f\x01\x7e\x60\x02\x7f\x7f\x00\x60\x02\x7f\x7e\x00\x60\x02\x7f\x7f\x01\x7f\x60\x02\x7f\x7e\x01\x7e\x60\x03\x7f\x7f\x7f\x01\x7f\x60\x03\x7f\x7e\x7e\x01\x7e\x03\xc1\x80\x80\x80\x00\x40\x00\x01\x02\x01\x01\x02\x02\x02\x03\x04\x03\x03\x04\x04\x04\x05\x06\x05\x05\x06\x06\x06\x05\x06\x05\x05\x06\x06\x06\x05\x06\x05\x05\x06\x06\x06\x05\x06\x05\x05\x06\x06\x06\x05\x06\x05\x05\x06\x06\x06\x05\x06\x05\x05\x06\x06\x06\x07\x08\x07\x07\x08\x08\x08\x05\x84\x80\x80\x80\x00\x01\x03\x01\x01\x07\xc4\x8b\x80\x80\x00\x40\x04\x69\x6e\x69\x74\x00\x00\x0f\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x02\x12\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x38\x5f\x75\x00\x03\x13\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x04\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x38\x5f\x75\x00\x05\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x06\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x07\x10\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x00\x08\x10\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x00\x09\x11\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x38\x00\x0a\x12\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x31\x36\x00\x0b\x11\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x38\x00\x0c\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x31\x36\x00\x0d\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x33\x32\x00\x0e\x12\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x61\x64\x64\x00\x0f\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x61\x64\x64\x00\x10\x15\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x61\x64\x64\x5f\x75\x00\x11\x16\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x61\x64\x64\x5f\x75\x00\x12\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x61\x64\x64\x5f\x75\x00\x13\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x61\x64\x64\x5f\x75\x00\x14\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x61\x64\x64\x5f\x75\x00\x15\x12\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x73\x75\x62\x00\x16\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x73\x75\x62\x00\x17\x15\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x73\x75\x62\x5f\x75\x00\x18\x16\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x73\x75\x62\x5f\x75\x00\x19\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x73\x75\x62\x5f\x75\x00\x1a\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x73\x75\x62\x5f\x75\x00\x1b\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x73\x75\x62\x5f\x75\x00\x1c\x12\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x61\x6e\x64\x00\x1d\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x61\x6e\x64\x00\x1e\x15\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x61\x6e\x64\x5f\x75\x00\x1f\x16\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x61\x6e\x64\x5f\x75\x00\x20\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x61\x6e\x64\x5f\x75\x00\x21\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x61\x6e\x64\x5f\x75\x00\x22\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x61\x6e\x64\x5f\x75\x00\x23\x11\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x6f\x72\x00\x24\x11\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x6f\x72\x00\x25\x14\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x6f\x72\x5f\x75\x00\x26\x15\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x6f\x72\x5f\x75\x00\x27\x14\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x6f\x72\x5f\x75\x00\x28\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x6f\x72\x5f\x75\x00\x29\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x6f\x72\x5f\x75\x00\x2a\x12\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x78\x6f\x72\x00\x2b\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x78\x6f\x72\x00\x2c\x15\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x78\x6f\x72\x5f\x75\x00\x2d\x16\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x78\x6f\x72\x5f\x75\x00\x2e\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x78\x6f\x72\x5f\x75\x00\x2f\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x78\x6f\x72\x5f\x75\x00\x30\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x78\x6f\x72\x5f\x75\x00\x31\x13\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x78\x63\x68\x67\x00\x32\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x78\x63\x68\x67\x00\x33\x16\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x78\x63\x68\x67\x5f\x75\x00\x34\x17\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x78\x63\x68\x67\x5f\x75\x00\x35\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x78\x63\x68\x67\x5f\x75\x00\x36\x17\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x78\x63\x68\x67\x5f\x75\x00\x37\x17\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x78\x63\x68\x67\x5f\x75\x00\x38\x16\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x63\x6d\x70\x78\x63\x68\x67\x00\x39\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x63\x6d\x70\x78\x63\x68\x67\x00\x3a\x19\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x3b\x1a\x69\x33\x32\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x3c\x19\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x3d\x1a\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x3e\x1a\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x3f\x0a\xc0\x87\x80\x80\x00\x40\x89\x80\x80\x80\x00\x00\x41\x00\x20\x00\x37\x03\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\xfe\x10\x02\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\xfe\x11\x03\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\xfe\x12\x00\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\xfe\x13\x01\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\xfe\x14\x00\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\xfe\x15\x01\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\xfe\x16\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x17\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x18\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x19\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x1a\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x1b\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x1c\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x1d\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x1e\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x1f\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x20\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x21\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x22\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x23\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x24\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x25\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x26\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x27\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x28\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x29\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x2a\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x2b\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x2c\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x2d\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x2e\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x2f\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x30\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x31\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x32\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x33\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x34\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x35\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x36\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x37\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x38\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x39\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x3a\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x3b\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x3c\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x3d\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x3e\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x3f\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x40\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x41\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x42\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x43\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x44\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x45\x00\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x46\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x47\x02\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x48\x02\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x49\x03\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x4a\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x4b\x01\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x4c\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x4d\x01\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x4e\x02\x00\x0b");
>+
>+// atomic.wast:84
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x80\x82\x88\x98\xc0\xa0\x81\x83\x07\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("506_097_522_914_230_528")]))
>+
>+// atomic.wast:86
>+assert_return(() => call($1, "i32.atomic.load", [0]), 50_462_976);
>+
>+// atomic.wast:87
>+assert_return(() => call($1, "i32.atomic.load", [4]), 117_835_012);
>+
>+// atomic.wast:89
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x80\x82\x88\x98\xc0\xa0\x81\x83\x07\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("506_097_522_914_230_528"))
>+
>+// atomic.wast:91
>+assert_return(() => call($1, "i32.atomic.load8_u", [0]), 0);
>+
>+// atomic.wast:92
>+assert_return(() => call($1, "i32.atomic.load8_u", [5]), 5);
>+
>+// atomic.wast:94
>+assert_return(() => call($1, "i32.atomic.load16_u", [0]), 256);
>+
>+// atomic.wast:95
>+assert_return(() => call($1, "i32.atomic.load16_u", [6]), 1_798);
>+
>+// atomic.wast:97
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x00\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load8_u", [0]), int64("0"))
>+
>+// atomic.wast:98
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x41\x05\x10\x00\x01\x42\x05\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load8_u", [5]), int64("5"))
>+
>+// atomic.wast:100
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x9a\x80\x80\x80\x00\x01\x02\x24\x31\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9a\x80\x80\x80\x00\x01\x94\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x80\x02\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load16_u", [0]), int64("256"))
>+
>+// atomic.wast:101
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x9a\x80\x80\x80\x00\x01\x02\x24\x31\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9a\x80\x80\x80\x00\x01\x94\x80\x80\x80\x00\x00\x02\x40\x41\x06\x10\x00\x01\x42\x86\x0e\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load16_u", [6]), int64("1_798"))
>+
>+// atomic.wast:103
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x9a\x80\x80\x80\x00\x01\x02\x24\x31\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x80\x82\x88\x18\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load32_u", [0]), int64("50_462_976"))
>+
>+// atomic.wast:104
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x9a\x80\x80\x80\x00\x01\x02\x24\x31\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9c\x80\x80\x80\x00\x01\x96\x80\x80\x80\x00\x00\x02\x40\x41\x04\x10\x00\x01\x42\x84\x8a\x98\x38\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load32_u", [4]), int64("117_835_012"))
>+
>+// atomic.wast:108
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x02\x40\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("0")]))
>+
>+// atomic.wast:110
>+assert_return(() => call($1, "i32.atomic.store", [0, -1_122_868]));
>+
>+// atomic.wast:111
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9d\x80\x80\x80\x00\x01\x97\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xcc\xbb\xbb\xff\x0f\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("4_293_844_428"))
>+
>+// atomic.wast:113
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x00\x02\x97\x80\x80\x80\x00\x01\x02\x24\x31\x10\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9b\x80\x80\x80\x00\x01\x95\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xef\x9b\xaf\xcd\xf8\xac\xd1\x91\x01\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.store", [0, int64("81_985_529_216_486_895")]))
>+
>+// atomic.wast:114
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\x9b\xaf\xcd\xf8\xac\xd1\x91\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("81_985_529_216_486_895"))
>+
>+// atomic.wast:116
>+assert_return(() => call($1, "i32.atomic.store8", [1, 66]));
>+
>+// atomic.wast:117
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\x85\xad\xcd\xf8\xac\xd1\x91\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("81_985_529_216_451_311"))
>+
>+// atomic.wast:119
>+assert_return(() => call($1, "i32.atomic.store16", [4, 34_884]));
>+
>+// atomic.wast:120
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\x85\xad\xcd\xc8\x88\xe2\x91\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("82_059_046_171_656_943"))
>+
>+// atomic.wast:122
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x00\x02\x98\x80\x80\x80\x00\x01\x02\x24\x31\x11\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x38\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x94\x80\x80\x80\x00\x01\x8e\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x99\x01\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.store8", [1, int64("153")]))
>+
>+// atomic.wast:123
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\xb3\xae\xcd\xc8\x88\xe2\x91\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("82_059_046_171_679_215"))
>+
>+// atomic.wast:125
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x00\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x31\x36\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x02\x40\x41\x04\x42\xfe\x95\x03\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.store16", [4, int64("51_966")]))
>+
>+// atomic.wast:126
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\xb3\xae\xcd\xe8\xdf\xf2\x91\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("82_132_412_803_029_487"))
>+
>+// atomic.wast:128
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x00\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x33\x32\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x97\x80\x80\x80\x00\x01\x91\x80\x80\x80\x00\x00\x02\x40\x41\x04\x42\xef\xfd\xb6\xf5\x0d\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.store32", [4, int64("3_735_928_559")]))
>+
>+// atomic.wast:129
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\xb3\xae\xcd\xf8\xdd\xef\xd6\x5e\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("-2_401_053_090_302_420_497"))
>+
>+// atomic.wast:133
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:134
>+assert_return(() => call($1, "i32.atomic.rmw.add", [0, 305_419_896]), 286_331_153);
>+
>+// atomic.wast:135
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x89\xcf\x95\x9a\x92\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_552_723_337"))
>+
>+// atomic.wast:137
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:138
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x61\x64\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xab\x80\x80\x80\x00\x01\xa5\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw.add", [0, int64("72_340_172_854_919_682")]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:139
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x93\xa6\xcc\x98\xa1\xc2\x84\x89\x12\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_302_123_111_102_223_123"))
>+
>+// atomic.wast:141
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:142
>+assert_return(() => call($1, "i32.atomic.rmw8.add_u", [0, -842_150_451]), 17);
>+
>+// atomic.wast:143
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xde\xa3\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_646"))
>+
>+// atomic.wast:145
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:146
>+assert_return(() => call($1, "i32.atomic.rmw16.add_u", [0, -889_271_554]), 4_369);
>+
>+// atomic.wast:147
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x8f\xb8\xc7\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_355_407"))
>+
>+// atomic.wast:149
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:150
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9c\x80\x80\x80\x00\x01\x02\x24\x31\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x61\x64\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa4\x80\x80\x80\x00\x01\x9e\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xc2\x84\x89\x92\xa4\xc8\x90\xa1\xc2\x00\x10\x00\x01\x42\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw8.add_u", [0, int64("4_774_451_407_313_060_418")]), int64("17"))
>+
>+// atomic.wast:151
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xd3\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_507"))
>+
>+// atomic.wast:153
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:154
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x61\x64\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xef\xfd\xbe\xf7\xfb\xdd\xef\xf7\xbe\x7f\x10\x00\x01\x42\x91\x22\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw16.add_u", [0, int64("-4_688_318_750_159_552_785")]), int64("4_369"))
>+
>+// atomic.wast:155
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x80\xa0\xc7\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_352_320"))
>+
>+// atomic.wast:157
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:158
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x61\x64\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa7\x80\x80\x80\x00\x01\xa1\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xe5\xcd\xee\xd5\xdc\xdc\xe9\xdd\x4a\x10\x00\x01\x42\x91\xa2\xc4\x88\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw32.add_u", [0, int64("-3_838_290_751_524_198_683")]), int64("286_331_153"))
>+
>+// atomic.wast:159
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xf6\xef\xb2\xde\x9d\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_941_648_599_030"))
>+
>+// atomic.wast:163
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:164
>+assert_return(() => call($1, "i32.atomic.rmw.sub", [0, 305_419_896]), 286_331_153);
>+
>+// atomic.wast:165
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x99\xf5\xf2\xf6\x9f\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_942_236_850_841"))
>+
>+// atomic.wast:167
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:168
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x73\x75\x62\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xab\x80\x80\x80\x00\x01\xa5\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw.sub", [0, int64("72_340_172_854_919_682")]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:169
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x8f\x9e\xbc\xf8\x80\x82\x84\x88\x10\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_157_442_765_392_383_759"))
>+
>+// atomic.wast:171
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:172
>+assert_return(() => call($1, "i32.atomic.rmw8.sub_u", [0, -842_150_451]), 17);
>+
>+// atomic.wast:173
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xc4\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_492"))
>+
>+// atomic.wast:175
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:176
>+assert_return(() => call($1, "i32.atomic.rmw16.sub_u", [0, -889_271_554]), 4_369);
>+
>+// atomic.wast:177
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x93\x8c\xc5\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_317_011"))
>+
>+// atomic.wast:179
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:180
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9c\x80\x80\x80\x00\x01\x02\x24\x31\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x73\x75\x62\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa4\x80\x80\x80\x00\x01\x9e\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xc2\x84\x89\x92\xa4\xc8\x90\xa1\xc2\x00\x10\x00\x01\x42\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw8.sub_u", [0, int64("4_774_451_407_313_060_418")]), int64("17"))
>+
>+// atomic.wast:181
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xcf\xa3\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_631"))
>+
>+// atomic.wast:183
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:184
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x73\x75\x62\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xef\xfd\xbe\xf7\xfb\xdd\xef\xf7\xbe\x7f\x10\x00\x01\x42\x91\x22\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw16.sub_u", [0, int64("-4_688_318_750_159_552_785")]), int64("4_369"))
>+
>+// atomic.wast:185
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xa2\xa4\xc5\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_320_098"))
>+
>+// atomic.wast:187
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:188
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x73\x75\x62\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa7\x80\x80\x80\x00\x01\xa1\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xe5\xcd\xee\xd5\xdc\xdc\xe9\xdd\x4a\x10\x00\x01\x42\x91\xa2\xc4\x88\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw32.sub_u", [0, int64("-3_838_290_751_524_198_683")]), int64("286_331_153"))
>+
>+// atomic.wast:189
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xac\xd4\xd5\xb2\x94\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_939_140_975_148"))
>+
>+// atomic.wast:193
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:194
>+assert_return(() => call($1, "i32.atomic.rmw.and", [0, 305_419_896]), 286_331_153);
>+
>+// atomic.wast:195
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x90\xa0\xc0\x80\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_230_460_432"))
>+
>+// atomic.wast:197
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:198
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x61\x6e\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xab\x80\x80\x80\x00\x01\xa5\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw.and", [0, int64("72_340_172_854_919_682")]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:199
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x80\x80\x80\x80\x90\xa0\xc0\x80\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("72_340_172_821_233_664"))
>+
>+// atomic.wast:201
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:202
>+assert_return(() => call($1, "i32.atomic.rmw8.and_u", [0, -842_150_451]), 17);
>+
>+// atomic.wast:203
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x81\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_425"))
>+
>+// atomic.wast:205
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:206
>+assert_return(() => call($1, "i32.atomic.rmw16.and_u", [0, -889_271_554]), 4_369);
>+
>+// atomic.wast:207
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x90\x80\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_299_088"))
>+
>+// atomic.wast:209
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:210
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9c\x80\x80\x80\x00\x01\x02\x24\x31\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x61\x6e\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa4\x80\x80\x80\x00\x01\x9e\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xc2\x84\x89\x92\xa4\xc8\x90\xa1\xc2\x00\x10\x00\x01\x42\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw8.and_u", [0, int64("4_774_451_407_313_060_418")]), int64("17"))
>+
>+// atomic.wast:211
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x80\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_424"))
>+
>+// atomic.wast:213
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:214
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x61\x6e\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xef\xfd\xbe\xf7\xfb\xdd\xef\xf7\xbe\x7f\x10\x00\x01\x42\x91\x22\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw16.and_u", [0, int64("-4_688_318_750_159_552_785")]), int64("4_369"))
>+
>+// atomic.wast:215
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x81\xa0\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_169"))
>+
>+// atomic.wast:217
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:218
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x61\x6e\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa7\x80\x80\x80\x00\x01\xa1\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xe5\xcd\xee\xd5\xdc\xdc\xe9\xdd\x4a\x10\x00\x01\x42\x91\xa2\xc4\x88\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw32.and_u", [0, int64("-3_838_290_751_524_198_683")]), int64("286_331_153"))
>+
>+// atomic.wast:219
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x81\x80\xc4\x80\x90\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_937_962_086_401"))
>+
>+// atomic.wast:223
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:224
>+assert_return(() => call($1, "i32.atomic.rmw.or", [0, 305_419_896]), 286_331_153);
>+
>+// atomic.wast:225
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xf9\xae\xd5\x99\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_283_235_193"))
>+
>+// atomic.wast:227
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:228
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x98\x80\x80\x80\x00\x01\x02\x24\x31\x11\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x6f\x72\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xab\x80\x80\x80\x00\x01\xa5\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw.or", [0, int64("72_340_172_854_919_682")]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:229
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x93\xa6\xcc\x98\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_280_989_459"))
>+
>+// atomic.wast:231
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:232
>+assert_return(() => call($1, "i32.atomic.rmw8.or_u", [0, -842_150_451]), 17);
>+
>+// atomic.wast:233
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xdd\xa3\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_645"))
>+
>+// atomic.wast:235
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:236
>+assert_return(() => call($1, "i32.atomic.rmw16.or_u", [0, -889_271_554]), 4_369);
>+
>+// atomic.wast:237
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xff\xb7\xc7\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_355_391"))
>+
>+// atomic.wast:239
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:240
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9b\x80\x80\x80\x00\x01\x02\x24\x31\x14\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa4\x80\x80\x80\x00\x01\x9e\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xc2\x84\x89\x92\xa4\xc8\x90\xa1\xc2\x00\x10\x00\x01\x42\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw8.or_u", [0, int64("4_774_451_407_313_060_418")]), int64("17"))
>+
>+// atomic.wast:241
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xd3\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_507"))
>+
>+// atomic.wast:243
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:244
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9c\x80\x80\x80\x00\x01\x02\x24\x31\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xef\xfd\xbe\xf7\xfb\xdd\xef\xf7\xbe\x7f\x10\x00\x01\x42\x91\x22\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw16.or_u", [0, int64("-4_688_318_750_159_552_785")]), int64("4_369"))
>+
>+// atomic.wast:245
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xff\xff\xc6\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_348_223"))
>+
>+// atomic.wast:247
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:248
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9c\x80\x80\x80\x00\x01\x02\x24\x31\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa7\x80\x80\x80\x00\x01\xa1\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xe5\xcd\xee\xd5\xdc\xdc\xe9\xdd\x4a\x10\x00\x01\x42\x91\xa2\xc4\x88\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw32.or_u", [0, int64("-3_838_290_751_524_198_683")]), int64("286_331_153"))
>+
>+// atomic.wast:249
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xf5\xef\xee\xdd\x9d\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_941_647_484_917"))
>+
>+// atomic.wast:253
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:254
>+assert_return(() => call($1, "i32.atomic.rmw.xor", [0, 305_419_896]), 286_331_153);
>+
>+// atomic.wast:255
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xe9\x8e\x95\x99\x90\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_013_747_049"))
>+
>+// atomic.wast:257
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:258
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x78\x6f\x72\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xab\x80\x80\x80\x00\x01\xa5\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw.xor", [0, int64("72_340_172_854_919_682")]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:259
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x93\xa6\xcc\x98\x81\x82\x84\x88\x10\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_157_442_765_459_755_795"))
>+
>+// atomic.wast:261
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:262
>+assert_return(() => call($1, "i32.atomic.rmw8.xor_u", [0, -842_150_451]), 17);
>+
>+// atomic.wast:263
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xdc\xa3\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_644"))
>+
>+// atomic.wast:265
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:266
>+assert_return(() => call($1, "i32.atomic.rmw16.xor_u", [0, -889_271_554]), 4_369);
>+
>+// atomic.wast:267
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\xb7\xc7\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_355_375"))
>+
>+// atomic.wast:269
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:270
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9c\x80\x80\x80\x00\x01\x02\x24\x31\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x78\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa4\x80\x80\x80\x00\x01\x9e\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xc2\x84\x89\x92\xa4\xc8\x90\xa1\xc2\x00\x10\x00\x01\x42\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw8.xor_u", [0, int64("4_774_451_407_313_060_418")]), int64("17"))
>+
>+// atomic.wast:271
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xd3\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_507"))
>+
>+// atomic.wast:273
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:274
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x78\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xef\xfd\xbe\xf7\xfb\xdd\xef\xf7\xbe\x7f\x10\x00\x01\x42\x91\x22\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw16.xor_u", [0, int64("-4_688_318_750_159_552_785")]), int64("4_369"))
>+
>+// atomic.wast:275
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xfe\xdf\xc6\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_344_126"))
>+
>+// atomic.wast:277
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:278
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x78\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa7\x80\x80\x80\x00\x01\xa1\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xe5\xcd\xee\xd5\xdc\xdc\xe9\xdd\x4a\x10\x00\x01\x42\x91\xa2\xc4\x88\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw32.xor_u", [0, int64("-3_838_290_751_524_198_683")]), int64("286_331_153"))
>+
>+// atomic.wast:279
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xf4\xef\xaa\xdd\x9d\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_941_646_370_804"))
>+
>+// atomic.wast:283
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:284
>+assert_return(() => call($1, "i32.atomic.rmw.xchg", [0, 305_419_896]), 286_331_153);
>+
>+// atomic.wast:285
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xf8\xac\xd1\x91\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_266_392_184"))
>+
>+// atomic.wast:287
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:288
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9a\x80\x80\x80\x00\x01\x02\x24\x31\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x78\x63\x68\x67\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xab\x80\x80\x80\x00\x01\xa5\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw.xchg", [0, int64("72_340_172_854_919_682")]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:289
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("72_340_172_854_919_682"))
>+
>+// atomic.wast:291
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:292
>+assert_return(() => call($1, "i32.atomic.rmw8.xchg_u", [0, -842_150_451]), 17);
>+
>+// atomic.wast:293
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xcd\xa3\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_629"))
>+
>+// atomic.wast:295
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:296
>+assert_return(() => call($1, "i32.atomic.rmw16.xchg_u", [0, -889_271_554]), 4_369);
>+
>+// atomic.wast:297
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xfe\x95\xc7\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_351_038"))
>+
>+// atomic.wast:299
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:300
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa4\x80\x80\x80\x00\x01\x9e\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xc2\x84\x89\x92\xa4\xc8\x90\xa1\xc2\x00\x10\x00\x01\x42\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw8.xchg_u", [0, int64("4_774_451_407_313_060_418")]), int64("17"))
>+
>+// atomic.wast:301
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xc2\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_490"))
>+
>+// atomic.wast:303
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:304
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9e\x80\x80\x80\x00\x01\x02\x24\x31\x17\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xef\xfd\xbe\xf7\xfb\xdd\xef\xf7\xbe\x7f\x10\x00\x01\x42\x91\x22\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw16.xchg_u", [0, int64("-4_688_318_750_159_552_785")]), int64("4_369"))
>+
>+// atomic.wast:305
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\xfd\xc6\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_347_951"))
>+
>+// atomic.wast:307
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:308
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9e\x80\x80\x80\x00\x01\x02\x24\x31\x17\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa7\x80\x80\x80\x00\x01\xa1\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\xe5\xcd\xee\xd5\xdc\xdc\xe9\xdd\x4a\x10\x00\x01\x42\x91\xa2\xc4\x88\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw32.xchg_u", [0, int64("-3_838_290_751_524_198_683")]), int64("286_331_153"))
>+
>+// atomic.wast:309
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xe5\xcd\xee\xd5\x9c\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_941_362_267_877"))
>+
>+// atomic.wast:313
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:314
>+assert_return(() => call($1, "i32.atomic.rmw.cmpxchg", [0, 0, 305_419_896]), 286_331_153);
>+
>+// atomic.wast:315
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:317
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:318
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x63\x6d\x70\x78\x63\x68\x67\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xad\x80\x80\x80\x00\x01\xa7\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x00\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw.cmpxchg", [0, int64("0"), int64("72_340_172_854_919_682")]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:319
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:321
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:322
>+assert_return(() => call($1, "i32.atomic.rmw8.cmpxchg_u", [0, 0, -842_150_451]), 17);
>+
>+// atomic.wast:323
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:325
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:326
>+assert_return(() => call($1, "i32.atomic.rmw16.cmpxchg_u", [0, 0, -889_271_554]), 4_369);
>+
>+// atomic.wast:327
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:329
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:330
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\xa0\x80\x80\x80\x00\x01\x02\x24\x31\x19\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa6\x80\x80\x80\x00\x01\xa0\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x00\x42\xc2\x84\x89\x92\xa4\xc8\x90\xa1\xc2\x00\x10\x00\x01\x42\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw8.cmpxchg_u", [0, int64("0"), int64("4_774_451_407_313_060_418")]), int64("17"))
>+
>+// atomic.wast:331
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:333
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:334
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\xa1\x80\x80\x80\x00\x01\x02\x24\x31\x1a\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa7\x80\x80\x80\x00\x01\xa1\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x00\x42\xef\xfd\xbe\xf7\xfb\xdd\xef\xf7\xbe\x7f\x10\x00\x01\x42\x91\x22\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw16.cmpxchg_u", [0, int64("0"), int64("-4_688_318_750_159_552_785")]), int64("4_369"))
>+
>+// atomic.wast:335
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:337
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:338
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\xa1\x80\x80\x80\x00\x01\x02\x24\x31\x1a\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa9\x80\x80\x80\x00\x01\xa3\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x00\x42\xe5\xcd\xee\xd5\xdc\xdc\xe9\xdd\x4a\x10\x00\x01\x42\x91\xa2\xc4\x88\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw32.cmpxchg_u", [0, int64("0"), int64("-3_838_290_751_524_198_683")]), int64("286_331_153"))
>+
>+// atomic.wast:339
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:343
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:344
>+assert_return(() => call($1, "i32.atomic.rmw.cmpxchg", [0, 286_331_153, 305_419_896]), 286_331_153);
>+
>+// atomic.wast:345
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xf8\xac\xd1\x91\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_266_392_184"))
>+
>+// atomic.wast:347
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:348
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x63\x6d\x70\x78\x63\x68\x67\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xb5\x80\x80\x80\x00\x01\xaf\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x10\x00\x01\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw.cmpxchg", [0, int64("1_229_782_938_247_303_441"), int64("72_340_172_854_919_682")]), int64("1_229_782_938_247_303_441"))
>+
>+// atomic.wast:349
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\x82\x84\x88\x90\x90\xa0\xc0\x80\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("72_340_172_854_919_682"))
>+
>+// atomic.wast:351
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:352
>+assert_return(() => call($1, "i32.atomic.rmw8.cmpxchg_u", [0, 17, -842_150_451]), 17);
>+
>+// atomic.wast:353
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xcd\xa3\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_629"))
>+
>+// atomic.wast:355
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:356
>+assert_return(() => call($1, "i32.atomic.rmw16.cmpxchg_u", [0, 4_369, -889_271_554]), 4_369);
>+
>+// atomic.wast:357
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xfe\x95\xc7\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_351_038"))
>+
>+// atomic.wast:359
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:360
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\xa0\x80\x80\x80\x00\x01\x02\x24\x31\x19\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x38\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa6\x80\x80\x80\x00\x01\xa0\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x11\x42\xc2\x84\x89\x92\xa4\xc8\x90\xa1\xc2\x00\x10\x00\x01\x42\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw8.cmpxchg_u", [0, int64("17"), int64("4_774_451_407_313_060_418")]), int64("17"))
>+
>+// atomic.wast:361
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xc2\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_303_490"))
>+
>+// atomic.wast:363
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:364
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\xa1\x80\x80\x80\x00\x01\x02\x24\x31\x1a\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa8\x80\x80\x80\x00\x01\xa2\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x91\x22\x42\xef\xfd\xbe\xf7\xfb\xdd\xef\xf7\xbe\x7f\x10\x00\x01\x42\x91\x22\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw16.cmpxchg_u", [0, int64("4_369"), int64("-4_688_318_750_159_552_785")]), int64("4_369"))
>+
>+// atomic.wast:365
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xef\xfd\xc6\x88\x91\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_938_247_347_951"))
>+
>+// atomic.wast:367
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x31\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x91\xa2\xc4\x88\x91\xa2\xc4\x88\x11\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // run(() => call($1, "init", [int64("1_229_782_938_247_303_441")]))
>+
>+// atomic.wast:368
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\xa1\x80\x80\x80\x00\x01\x02\x24\x31\x1a\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xad\x80\x80\x80\x00\x01\xa7\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x91\xa2\xc4\x88\x01\x42\xe5\xcd\xee\xd5\xdc\xdc\xe9\xdd\x4a\x10\x00\x01\x42\x91\xa2\xc4\x88\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.rmw32.cmpxchg_u", [0, int64("286_331_153"), int64("-3_838_290_751_524_198_683")]), int64("286_331_153"))
>+
>+// atomic.wast:369
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x41\x00\x10\x00\x01\x42\xe5\xcd\xee\xd5\x9c\xa2\xc4\x88\x11\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_return(() => call($1, "i64.atomic.load", [0]), int64("1_229_782_941_362_267_877"))
>+
>+// atomic.wast:374
>+assert_trap(() => call($1, "i32.atomic.load", [1]));
>+
>+// atomic.wast:375
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x96\x80\x80\x80\x00\x01\x02\x24\x31\x0f\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x02\x40\x41\x01\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.load", [1]))
>+
>+// atomic.wast:376
>+assert_trap(() => call($1, "i32.atomic.load16_u", [1]));
>+
>+// atomic.wast:377
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x9a\x80\x80\x80\x00\x01\x02\x24\x31\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x02\x40\x41\x01\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.load16_u", [1]))
>+
>+// atomic.wast:378
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7f\x01\x7e\x02\x9a\x80\x80\x80\x00\x01\x02\x24\x31\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x02\x40\x41\x01\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.load32_u", [1]))
>+
>+// atomic.wast:379
>+assert_trap(() => call($1, "i32.atomic.store", [1, 0]));
>+
>+// atomic.wast:380
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x00\x02\x97\x80\x80\x80\x00\x01\x02\x24\x31\x10\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.store", [1, int64("0")]))
>+
>+// atomic.wast:381
>+assert_trap(() => call($1, "i32.atomic.store16", [1, 0]));
>+
>+// atomic.wast:382
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x00\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x31\x36\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.store16", [1, int64("0")]))
>+
>+// atomic.wast:383
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x00\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x73\x74\x6f\x72\x65\x33\x32\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.store32", [1, int64("0")]))
>+
>+// atomic.wast:384
>+assert_trap(() => call($1, "i32.atomic.rmw.add", [1, 0]));
>+
>+// atomic.wast:385
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x61\x64\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw.add", [1, int64("0")]))
>+
>+// atomic.wast:386
>+assert_trap(() => call($1, "i32.atomic.rmw16.add_u", [1, 0]));
>+
>+// atomic.wast:387
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x61\x64\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw16.add_u", [1, int64("0")]))
>+
>+// atomic.wast:388
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x61\x64\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw32.add_u", [1, int64("0")]))
>+
>+// atomic.wast:389
>+assert_trap(() => call($1, "i32.atomic.rmw.sub", [1, 0]));
>+
>+// atomic.wast:390
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x73\x75\x62\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw.sub", [1, int64("0")]))
>+
>+// atomic.wast:391
>+assert_trap(() => call($1, "i32.atomic.rmw16.sub_u", [1, 0]));
>+
>+// atomic.wast:392
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x73\x75\x62\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw16.sub_u", [1, int64("0")]))
>+
>+// atomic.wast:393
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x73\x75\x62\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw32.sub_u", [1, int64("0")]))
>+
>+// atomic.wast:394
>+assert_trap(() => call($1, "i32.atomic.rmw.and", [1, 0]));
>+
>+// atomic.wast:395
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x61\x6e\x64\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw.and", [1, int64("0")]))
>+
>+// atomic.wast:396
>+assert_trap(() => call($1, "i32.atomic.rmw16.and_u", [1, 0]));
>+
>+// atomic.wast:397
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x61\x6e\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw16.and_u", [1, int64("0")]))
>+
>+// atomic.wast:398
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x61\x6e\x64\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw32.and_u", [1, int64("0")]))
>+
>+// atomic.wast:399
>+assert_trap(() => call($1, "i32.atomic.rmw.or", [1, 0]));
>+
>+// atomic.wast:400
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x98\x80\x80\x80\x00\x01\x02\x24\x31\x11\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x6f\x72\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw.or", [1, int64("0")]))
>+
>+// atomic.wast:401
>+assert_trap(() => call($1, "i32.atomic.rmw16.or_u", [1, 0]));
>+
>+// atomic.wast:402
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9c\x80\x80\x80\x00\x01\x02\x24\x31\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw16.or_u", [1, int64("0")]))
>+
>+// atomic.wast:403
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9c\x80\x80\x80\x00\x01\x02\x24\x31\x15\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw32.or_u", [1, int64("0")]))
>+
>+// atomic.wast:404
>+assert_trap(() => call($1, "i32.atomic.rmw.xor", [1, 0]));
>+
>+// atomic.wast:405
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x99\x80\x80\x80\x00\x01\x02\x24\x31\x12\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x78\x6f\x72\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw.xor", [1, int64("0")]))
>+
>+// atomic.wast:406
>+assert_trap(() => call($1, "i32.atomic.rmw16.xor_u", [1, 0]));
>+
>+// atomic.wast:407
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x78\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw16.xor_u", [1, int64("0")]))
>+
>+// atomic.wast:408
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x78\x6f\x72\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw32.xor_u", [1, int64("0")]))
>+
>+// atomic.wast:409
>+assert_trap(() => call($1, "i32.atomic.rmw.xchg", [1, 0]));
>+
>+// atomic.wast:410
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9a\x80\x80\x80\x00\x01\x02\x24\x31\x13\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x78\x63\x68\x67\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw.xchg", [1, int64("0")]))
>+
>+// atomic.wast:411
>+assert_trap(() => call($1, "i32.atomic.rmw16.xchg_u", [1, 0]));
>+
>+// atomic.wast:412
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9e\x80\x80\x80\x00\x01\x02\x24\x31\x17\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw16.xchg_u", [1, int64("0")]))
>+
>+// atomic.wast:413
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8a\x80\x80\x80\x00\x02\x60\x00\x00\x60\x02\x7f\x7e\x01\x7e\x02\x9e\x80\x80\x80\x00\x01\x02\x24\x31\x17\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw32.xchg_u", [1, int64("0")]))
>+
>+// atomic.wast:414
>+assert_trap(() => call($1, "i32.atomic.rmw.cmpxchg", [1, 0, 0]));
>+
>+// atomic.wast:415
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\x9d\x80\x80\x80\x00\x01\x02\x24\x31\x16\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x2e\x63\x6d\x70\x78\x63\x68\x67\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw.cmpxchg", [1, int64("0"), int64("0")]))
>+
>+// atomic.wast:416
>+assert_trap(() => call($1, "i32.atomic.rmw16.cmpxchg_u", [1, 0, 0]));
>+
>+// atomic.wast:417
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\xa1\x80\x80\x80\x00\x01\x02\x24\x31\x1a\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x31\x36\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw16.cmpxchg_u", [1, int64("0"), int64("0")]))
>+
>+// atomic.wast:418
>+assert_trap(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7e\x02\xa1\x80\x80\x80\x00\x01\x02\x24\x31\x1a\x69\x36\x34\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x72\x6d\x77\x33\x32\x2e\x63\x6d\x70\x78\x63\x68\x67\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x95\x80\x80\x80\x00\x01\x8f\x80\x80\x80\x00\x00\x02\x40\x41\x01\x42\x00\x42\x00\x10\x00\x0f\x0b\x00\x0b", exports("$1", $1)),  "run", []));  // assert_trap(() => call($1, "i64.atomic.rmw32.cmpxchg_u", [1, int64("0"), int64("0")]))
>+
>+// atomic.wast:420
>+let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x99\x80\x80\x80\x00\x04\x60\x01\x7e\x00\x60\x02\x7f\x7f\x01\x7f\x60\x03\x7f\x7f\x7e\x01\x7f\x60\x03\x7f\x7e\x7e\x01\x7f\x03\x85\x80\x80\x80\x00\x04\x00\x01\x02\x03\x05\x84\x80\x80\x80\x00\x01\x03\x01\x01\x07\xcd\x80\x80\x80\x00\x04\x04\x69\x6e\x69\x74\x00\x00\x14\x6d\x65\x6d\x6f\x72\x79\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x6e\x6f\x74\x69\x66\x79\x00\x01\x14\x6d\x65\x6d\x6f\x72\x79\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x77\x61\x69\x74\x33\x32\x00\x02\x14\x6d\x65\x6d\x6f\x72\x79\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x77\x61\x69\x74\x36\x34\x00\x03\x0a\xc0\x80\x80\x80\x00\x04\x89\x80\x80\x80\x00\x00\x41\x00\x20\x00\x37\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x20\x00\x20\x01\xfe\x00\x02\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x01\x02\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfe\x02\x03\x00\x0b");
>+
>+// atomic.wast:433
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x00\x02\x8b\x80\x80\x80\x00\x01\x02\x24\x32\x04\x69\x6e\x69\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x97\x80\x80\x80\x00\x01\x91\x80\x80\x80\x00\x00\x02\x40\x42\xff\xff\xff\xff\xff\xff\x3f\x10\x00\x0f\x0b\x00\x0b", exports("$2", $2)),  "run", []));  // run(() => call($2, "init", [int64("281_474_976_710_655")]))
>+
>+// atomic.wast:434
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7f\x7e\x01\x7f\x02\x9b\x80\x80\x80\x00\x01\x02\x24\x32\x14\x6d\x65\x6d\x6f\x72\x79\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x77\x61\x69\x74\x33\x32\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9d\x80\x80\x80\x00\x01\x97\x80\x80\x80\x00\x00\x02\x40\x41\x00\x41\x00\x42\x00\x10\x00\x01\x41\x01\x01\x46\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$2", $2)),  "run", []));  // assert_return(() => call($2, "memory.atomic.wait32", [0, 0, int64("0")]), 1)
>+
>+// atomic.wast:435
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8b\x80\x80\x80\x00\x02\x60\x00\x00\x60\x03\x7f\x7e\x7e\x01\x7f\x02\x9b\x80\x80\x80\x00\x01\x02\x24\x32\x14\x6d\x65\x6d\x6f\x72\x79\x2e\x61\x74\x6f\x6d\x69\x63\x2e\x77\x61\x69\x74\x36\x34\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9d\x80\x80\x80\x00\x01\x97\x80\x80\x80\x00\x00\x02\x40\x41\x00\x42\x00\x42\x00\x10\x00\x01\x41\x01\x01\x46\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$2", $2)),  "run", []));  // assert_return(() => call($2, "memory.atomic.wait64", [0, int64("0"), int64("0")]), 1)
>+
>+// atomic.wast:436
>+assert_return(() => call($2, "memory.atomic.notify", [0, 0]), 0);
>+
>+// atomic.wast:439
>+let $3 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\xb1\x80\x80\x80\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x0a\x80\x86\x80\x80\x00\x30\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x00\x02\x00\x1a\x0b\x8d\x80\x80\x80\x00\x00\x41\x00\x41\x00\x42\x00\xfe\x01\x02\x00\x1a\x0b\x8d\x80\x80\x80\x00\x00\x41\x00\x42\x00\x42\x00\xfe\x02\x03\x00\x1a\x0b\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x10\x02\x00\x1a\x0b\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x11\x03\x00\x1a\x0b\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x13\x01\x00\x1a\x0b\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x15\x01\x00\x1a\x0b\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x16\x02\x00\x1a\x0b\x8a\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x17\x02\x00\x0b\x8a\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x18\x03\x00\x0b\x8a\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x1a\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x1c\x01\x00\x0b\x8a\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x1d\x02\x00\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x1e\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x1f\x03\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x21\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x23\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x24\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x25\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x26\x03\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x28\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x2a\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x2b\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x2c\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x2d\x03\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x2f\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x31\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x32\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x33\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x34\x03\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x36\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x38\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x39\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x3a\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x3b\x03\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x3d\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x3f\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x40\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x41\x02\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x42\x03\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x44\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x46\x01\x00\x1a\x0b\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x47\x02\x00\x1a\x0b\x8d\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x00\xfe\x48\x02\x00\x1a\x0b\x8d\x80\x80\x80\x00\x00\x41\x00\x42\x00\x42\x00\xfe\x49\x03\x00\x1a\x0b\x8d\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x00\xfe\x4b\x01\x00\x1a\x0b\x8d\x80\x80\x80\x00\x00\x41\x00\x42\x00\x42\x00\xfe\x4d\x01\x00\x1a\x0b\x8d\x80\x80\x80\x00\x00\x41\x00\x42\x00\x42\x00\xfe\x4e\x02\x00\x1a\x0b");
>+
>+// atomic.wast:492
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x00\x02\x00\x1a\x0b");
>+
>+// atomic.wast:493
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x41\x00\x41\x00\x42\x00\xfe\x01\x02\x00\x1a\x0b");
>+
>+// atomic.wast:494
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x41\x00\x42\x00\x42\x00\xfe\x02\x03\x00\x1a\x0b");
>+
>+// atomic.wast:495
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8f\x80\x80\x80\x00\x01\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x10\x02\x00\x1a\x0b");
>+
>+// atomic.wast:496
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8f\x80\x80\x80\x00\x01\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x11\x03\x00\x1a\x0b");
>+
>+// atomic.wast:497
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8f\x80\x80\x80\x00\x01\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x13\x01\x00\x1a\x0b");
>+
>+// atomic.wast:498
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8f\x80\x80\x80\x00\x01\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x15\x01\x00\x1a\x0b");
>+
>+// atomic.wast:499
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8f\x80\x80\x80\x00\x01\x89\x80\x80\x80\x00\x00\x41\x00\xfe\x16\x02\x00\x1a\x0b");
>+
>+// atomic.wast:500
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x90\x80\x80\x80\x00\x01\x8a\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x17\x02\x00\x0b");
>+
>+// atomic.wast:501
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x90\x80\x80\x80\x00\x01\x8a\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x18\x03\x00\x0b");
>+
>+// atomic.wast:502
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x90\x80\x80\x80\x00\x01\x8a\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x1a\x01\x00\x0b");
>+
>+// atomic.wast:503
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x90\x80\x80\x80\x00\x01\x8a\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x1c\x01\x00\x0b");
>+
>+// atomic.wast:504
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x90\x80\x80\x80\x00\x01\x8a\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x1d\x02\x00\x0b");
>+
>+// atomic.wast:505
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x1e\x02\x00\x1a\x0b");
>+
>+// atomic.wast:506
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x1f\x03\x00\x1a\x0b");
>+
>+// atomic.wast:507
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x21\x01\x00\x1a\x0b");
>+
>+// atomic.wast:508
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x23\x01\x00\x1a\x0b");
>+
>+// atomic.wast:509
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x24\x02\x00\x1a\x0b");
>+
>+// atomic.wast:510
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x25\x02\x00\x1a\x0b");
>+
>+// atomic.wast:511
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x26\x03\x00\x1a\x0b");
>+
>+// atomic.wast:512
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x28\x01\x00\x1a\x0b");
>+
>+// atomic.wast:513
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x2a\x01\x00\x1a\x0b");
>+
>+// atomic.wast:514
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x2b\x02\x00\x1a\x0b");
>+
>+// atomic.wast:515
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x2c\x02\x00\x1a\x0b");
>+
>+// atomic.wast:516
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x2d\x03\x00\x1a\x0b");
>+
>+// atomic.wast:517
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x2f\x01\x00\x1a\x0b");
>+
>+// atomic.wast:518
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x31\x01\x00\x1a\x0b");
>+
>+// atomic.wast:519
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x32\x02\x00\x1a\x0b");
>+
>+// atomic.wast:520
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x33\x02\x00\x1a\x0b");
>+
>+// atomic.wast:521
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x34\x03\x00\x1a\x0b");
>+
>+// atomic.wast:522
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x36\x01\x00\x1a\x0b");
>+
>+// atomic.wast:523
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x38\x01\x00\x1a\x0b");
>+
>+// atomic.wast:524
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x39\x02\x00\x1a\x0b");
>+
>+// atomic.wast:525
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x3a\x02\x00\x1a\x0b");
>+
>+// atomic.wast:526
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x3b\x03\x00\x1a\x0b");
>+
>+// atomic.wast:527
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x3d\x01\x00\x1a\x0b");
>+
>+// atomic.wast:528
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x3f\x01\x00\x1a\x0b");
>+
>+// atomic.wast:529
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x40\x02\x00\x1a\x0b");
>+
>+// atomic.wast:530
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x41\x02\x00\x1a\x0b");
>+
>+// atomic.wast:531
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x42\x03\x00\x1a\x0b");
>+
>+// atomic.wast:532
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x41\x00\xfe\x44\x01\x00\x1a\x0b");
>+
>+// atomic.wast:533
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x46\x01\x00\x1a\x0b");
>+
>+// atomic.wast:534
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x91\x80\x80\x80\x00\x01\x8b\x80\x80\x80\x00\x00\x41\x00\x42\x00\xfe\x47\x02\x00\x1a\x0b");
>+
>+// atomic.wast:535
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x00\xfe\x48\x02\x00\x1a\x0b");
>+
>+// atomic.wast:536
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x41\x00\x42\x00\x42\x00\xfe\x49\x03\x00\x1a\x0b");
>+
>+// atomic.wast:537
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x00\xfe\x4b\x01\x00\x1a\x0b");
>+
>+// atomic.wast:538
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x41\x00\x42\x00\x42\x00\xfe\x4d\x01\x00\x1a\x0b");
>+
>+// atomic.wast:539
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x93\x80\x80\x80\x00\x01\x8d\x80\x80\x80\x00\x00\x41\x00\x42\x00\x42\x00\xfe\x4e\x02\x00\x1a\x0b");
>diff --git a/JSTests/wasm/threads-spec-tests/memory.wast.js b/JSTests/wasm/threads-spec-tests/memory.wast.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..2e44d74fde9b99a830e3db4969b783fdaec6ebbe
>--- /dev/null
>+++ b/JSTests/wasm/threads-spec-tests/memory.wast.js
>@@ -0,0 +1,246 @@
>+
>+// memory.wast:3
>+let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x83\x80\x80\x80\x00\x01\x00\x00");
>+
>+// memory.wast:4
>+let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x83\x80\x80\x80\x00\x01\x00\x01");
>+
>+// memory.wast:5
>+let $3 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x84\x80\x80\x80\x00\x01\x01\x00\x00");
>+
>+// memory.wast:6
>+let $4 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x84\x80\x80\x80\x00\x01\x01\x00\x01");
>+
>+// memory.wast:7
>+let $5 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x85\x80\x80\x80\x00\x01\x01\x01\x80\x02");
>+
>+// memory.wast:8
>+let $6 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x86\x80\x80\x80\x00\x01\x01\x00\x80\x80\x04");
>+
>+// memory.wast:9
>+let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x84\x80\x80\x80\x00\x01\x03\x00\x00");
>+
>+// memory.wast:10
>+let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x84\x80\x80\x80\x00\x01\x03\x01\x02");
>+
>+// memory.wast:12
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x83\x80\x80\x80\x00\x01\x02\x01");
>+
>+// memory.wast:14
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x85\x80\x80\x80\x00\x02\x00\x00\x00\x00");
>+
>+// memory.wast:15
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x06\x6d\x65\x6d\x6f\x72\x79\x02\x00\x00\x05\x83\x80\x80\x80\x00\x01\x00\x00");
>+
>+// memory.wast:17
>+let $9 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x00\x00\x07\x8b\x80\x80\x80\x00\x01\x07\x6d\x65\x6d\x73\x69\x7a\x65\x00\x00\x0a\x8a\x80\x80\x80\x00\x01\x84\x80\x80\x80\x00\x00\x3f\x00\x0b\x0b\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");
>+
>+// memory.wast:18
>+assert_return(() => call($9, "memsize", []), 0);
>+
>+// memory.wast:19
>+let $10 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x00\x00\x07\x8b\x80\x80\x80\x00\x01\x07\x6d\x65\x6d\x73\x69\x7a\x65\x00\x00\x0a\x8a\x80\x80\x80\x00\x01\x84\x80\x80\x80\x00\x00\x3f\x00\x0b\x0b\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");
>+
>+// memory.wast:20
>+assert_return(() => call($10, "memsize", []), 0);
>+
>+// memory.wast:21
>+let $11 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x82\x80\x80\x80\x00\x01\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x01\x07\x8b\x80\x80\x80\x00\x01\x07\x6d\x65\x6d\x73\x69\x7a\x65\x00\x00\x0a\x8a\x80\x80\x80\x00\x01\x84\x80\x80\x80\x00\x00\x3f\x00\x0b\x0b\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x78");
>+
>+// memory.wast:22
>+assert_return(() => call($11, "memsize", []), 1);
>+
>+// memory.wast:24
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x0b\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");
>+
>+// memory.wast:25
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x0b\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");
>+
>+// memory.wast:26
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x0b\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x78");
>+
>+// memory.wast:28
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8e\x80\x80\x80\x00\x01\x88\x80\x80\x80\x00\x00\x41\x00\x2a\x02\x00\x1a\x0b");
>+
>+// memory.wast:32
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x41\x00\x43\x00\x00\x00\x00\x38\x02\x00\x0b");
>+
>+// memory.wast:36
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8e\x80\x80\x80\x00\x01\x88\x80\x80\x80\x00\x00\x41\x00\x2c\x00\x00\x1a\x0b");
>+
>+// memory.wast:40
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8f\x80\x80\x80\x00\x01\x89\x80\x80\x80\x00\x00\x41\x00\x41\x00\x3a\x00\x00\x0b");
>+
>+// memory.wast:44
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8b\x80\x80\x80\x00\x01\x85\x80\x80\x80\x00\x00\x3f\x00\x1a\x0b");
>+
>+// memory.wast:48
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8d\x80\x80\x80\x00\x01\x87\x80\x80\x80\x00\x00\x41\x00\x40\x00\x1a\x0b");
>+
>+// memory.wast:54
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x84\x80\x80\x80\x00\x01\x01\x01\x00");
>+
>+// memory.wast:58
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x85\x80\x80\x80\x00\x01\x00\x81\x80\x04");
>+
>+// memory.wast:62
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x87\x80\x80\x80\x00\x01\x00\x80\x80\x80\x80\x08");
>+
>+// memory.wast:66
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x87\x80\x80\x80\x00\x01\x00\xff\xff\xff\xff\x0f");
>+
>+// memory.wast:70
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x86\x80\x80\x80\x00\x01\x01\x00\x81\x80\x04");
>+
>+// memory.wast:74
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x88\x80\x80\x80\x00\x01\x01\x00\x80\x80\x80\x80\x08");
>+
>+// memory.wast:78
>+assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x05\x88\x80\x80\x80\x00\x01\x01\x00\xff\xff\xff\xff\x0f");
>+
>+// memory.wast:83
>+assert_malformed("\x3c\x6d\x61\x6c\x66\x6f\x72\x6d\x65\x64\x20\x71\x75\x6f\x74\x65\x3e");
>+
>+// memory.wast:87
>+assert_malformed("\x3c\x6d\x61\x6c\x66\x6f\x72\x6d\x65\x64\x20\x71\x75\x6f\x74\x65\x3e");
>+
>+// memory.wast:91
>+assert_malformed("\x3c\x6d\x61\x6c\x66\x6f\x72\x6d\x65\x64\x20\x71\x75\x6f\x74\x65\x3e");
>+
>+// memory.wast:96
>+let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x93\x80\x80\x80\x00\x04\x60\x00\x01\x7f\x60\x00\x01\x7c\x60\x01\x7f\x01\x7f\x60\x01\x7e\x01\x7e\x03\x8d\x80\x80\x80\x00\x0c\x00\x01\x02\x02\x02\x02\x03\x03\x03\x03\x03\x03\x05\x83\x80\x80\x80\x00\x01\x00\x01\x07\xa1\x81\x80\x80\x00\x0c\x04\x64\x61\x74\x61\x00\x00\x04\x63\x61\x73\x74\x00\x01\x0b\x69\x33\x32\x5f\x6c\x6f\x61\x64\x38\x5f\x73\x00\x02\x0b\x69\x33\x32\x5f\x6c\x6f\x61\x64\x38\x5f\x75\x00\x03\x0c\x69\x33\x32\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x73\x00\x04\x0c\x69\x33\x32\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x05\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x73\x00\x06\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x75\x00\x07\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x73\x00\x08\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x09\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x73\x00\x0a\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x0b\x0a\xcf\x82\x80\x80\x00\x0c\xce\x80\x80\x80\x00\x00\x41\x00\x2d\x00\x00\x41\xc1\x00\x46\x41\x03\x2d\x00\x00\x41\xa7\x01\x46\x71\x41\x06\x2d\x00\x00\x41\x00\x46\x41\x13\x2d\x00\x00\x41\x00\x46\x71\x71\x41\x14\x2d\x00\x00\x41\xd7\x00\x46\x41\x17\x2d\x00\x00\x41\xcd\x00\x46\x71\x41\x18\x2d\x00\x00\x41\x00\x46\x41\xff\x07\x2d\x00\x00\x41\x00\x46\x71\x71\x71\x0b\xb8\x80\x80\x80\x00\x00\x41\x08\x42\xc7\x9f\x7f\x37\x03\x00\x41\x08\x2b\x03\x00\x42\xc7\x9f\x7f\xbf\x61\x04\x40\x44\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x0b\x41\x09\x42\x00\x37\x00\x00\x41\x0f\x41\xc5\x80\x01\x3b\x00\x00\x41\x09\x2b\x00\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3a\x00\x00\x41\x08\x2c\x00\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3a\x00\x00\x41\x08\x2d\x00\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3b\x01\x00\x41\x08\x2e\x01\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3b\x01\x00\x41\x08\x2f\x01\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3c\x00\x00\x41\x08\x30\x00\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3c\x00\x00\x41\x08\x31\x00\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3d\x01\x00\x41\x08\x32\x01\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3d\x01\x00\x41\x08\x33\x01\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3e\x02\x00\x41\x08\x34\x02\x00\x0b\x8e\x80\x80\x80\x00\x00\x41\x08\x20\x00\x3e\x02\x00\x41\x08\x35\x02\x00\x0b\x0b\x94\x80\x80\x80\x00\x02\x00\x41\x00\x0b\x05\x41\x42\x43\xa7\x44\x00\x41\x14\x0b\x04\x57\x41\x53\x4d");
>+
>+// memory.wast:184
>+assert_return(() => call($12, "data", []), 1);
>+
>+// memory.wast:185
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x00\x60\x00\x01\x7c\x02\x8c\x80\x80\x80\x00\x01\x03\x24\x31\x32\x04\x63\x61\x73\x74\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9e\x80\x80\x80\x00\x01\x98\x80\x80\x80\x00\x00\x02\x40\x10\x00\xbd\x44\x00\x00\x00\x00\x00\x00\x45\x40\xbd\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "cast", []), 42.)
>+
>+// memory.wast:187
>+assert_return(() => call($12, "i32_load8_s", [-1]), -1);
>+
>+// memory.wast:188
>+assert_return(() => call($12, "i32_load8_u", [-1]), 255);
>+
>+// memory.wast:189
>+assert_return(() => call($12, "i32_load16_s", [-1]), -1);
>+
>+// memory.wast:190
>+assert_return(() => call($12, "i32_load16_u", [-1]), 65_535);
>+
>+// memory.wast:192
>+assert_return(() => call($12, "i32_load8_s", [100]), 100);
>+
>+// memory.wast:193
>+assert_return(() => call($12, "i32_load8_u", [200]), 200);
>+
>+// memory.wast:194
>+assert_return(() => call($12, "i32_load16_s", [20_000]), 20_000);
>+
>+// memory.wast:195
>+assert_return(() => call($12, "i32_load16_u", [40_000]), 40_000);
>+
>+// memory.wast:197
>+assert_return(() => call($12, "i32_load8_s", [-19_110_589]), 67);
>+
>+// memory.wast:198
>+assert_return(() => call($12, "i32_load8_s", [878_104_047]), -17);
>+
>+// memory.wast:199
>+assert_return(() => call($12, "i32_load8_u", [-19_110_589]), 67);
>+
>+// memory.wast:200
>+assert_return(() => call($12, "i32_load8_u", [878_104_047]), 239);
>+
>+// memory.wast:201
>+assert_return(() => call($12, "i32_load16_s", [-19_110_589]), 25_923);
>+
>+// memory.wast:202
>+assert_return(() => call($12, "i32_load16_s", [878_104_047]), -12_817);
>+
>+// memory.wast:203
>+assert_return(() => call($12, "i32_load16_u", [-19_110_589]), 25_923);
>+
>+// memory.wast:204
>+assert_return(() => call($12, "i32_load16_u", [878_104_047]), 52_719);
>+
>+// memory.wast:206
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x93\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x7f\x10\x00\x01\x42\x7f\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load8_s", [int64("-1")]), int64("-1"))
>+
>+// memory.wast:207
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x93\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9a\x80\x80\x80\x00\x01\x94\x80\x80\x80\x00\x00\x02\x40\x42\x7f\x10\x00\x01\x42\xff\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load8_u", [int64("-1")]), int64("255"))
>+
>+// memory.wast:208
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x7f\x10\x00\x01\x42\x7f\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load16_s", [int64("-1")]), int64("-1"))
>+
>+// memory.wast:209
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9b\x80\x80\x80\x00\x01\x95\x80\x80\x80\x00\x00\x02\x40\x42\x7f\x10\x00\x01\x42\xff\xff\x03\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load16_u", [int64("-1")]), int64("65_535"))
>+
>+// memory.wast:210
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x99\x80\x80\x80\x00\x01\x93\x80\x80\x80\x00\x00\x02\x40\x42\x7f\x10\x00\x01\x42\x7f\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load32_s", [int64("-1")]), int64("-1"))
>+
>+// memory.wast:211
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9d\x80\x80\x80\x00\x01\x97\x80\x80\x80\x00\x00\x02\x40\x42\x7f\x10\x00\x01\x42\xff\xff\xff\xff\x0f\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load32_u", [int64("-1")]), int64("4_294_967_295"))
>+
>+// memory.wast:213
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x93\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9b\x80\x80\x80\x00\x01\x95\x80\x80\x80\x00\x00\x02\x40\x42\xe4\x00\x10\x00\x01\x42\xe4\x00\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load8_s", [int64("100")]), int64("100"))
>+
>+// memory.wast:214
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x93\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9b\x80\x80\x80\x00\x01\x95\x80\x80\x80\x00\x00\x02\x40\x42\xc8\x01\x10\x00\x01\x42\xc8\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load8_u", [int64("200")]), int64("200"))
>+
>+// memory.wast:215
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9d\x80\x80\x80\x00\x01\x97\x80\x80\x80\x00\x00\x02\x40\x42\xa0\x9c\x01\x10\x00\x01\x42\xa0\x9c\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load16_s", [int64("20_000")]), int64("20_000"))
>+
>+// memory.wast:216
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9d\x80\x80\x80\x00\x01\x97\x80\x80\x80\x00\x00\x02\x40\x42\xc0\xb8\x02\x10\x00\x01\x42\xc0\xb8\x02\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load16_u", [int64("40_000")]), int64("40_000"))
>+
>+// memory.wast:217
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9d\x80\x80\x80\x00\x01\x97\x80\x80\x80\x00\x00\x02\x40\x42\xa0\x9c\x01\x10\x00\x01\x42\xa0\x9c\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load32_s", [int64("20_000")]), int64("20_000"))
>+
>+// memory.wast:218
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\x9d\x80\x80\x80\x00\x01\x97\x80\x80\x80\x00\x00\x02\x40\x42\xc0\xb8\x02\x10\x00\x01\x42\xc0\xb8\x02\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load32_u", [int64("40_000")]), int64("40_000"))
>+
>+// memory.wast:220
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x93\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa2\x80\x80\x80\x00\x01\x9c\x80\x80\x80\x00\x00\x02\x40\x42\xc3\xca\xd1\xb1\x85\xd3\xae\xee\x7e\x10\x00\x01\x42\xc3\x00\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load8_s", [int64("-81_985_529_755_441_853")]), int64("67"))
>+
>+// memory.wast:221
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x93\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa1\x80\x80\x80\x00\x01\x9b\x80\x80\x80\x00\x00\x02\x40\x42\xef\x9b\xeb\xc5\xd9\xec\x90\xab\x34\x10\x00\x01\x42\x6f\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load8_s", [int64("3_771_275_841_602_506_223")]), int64("-17"))
>+
>+// memory.wast:222
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x93\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa2\x80\x80\x80\x00\x01\x9c\x80\x80\x80\x00\x00\x02\x40\x42\xc3\xca\xd1\xb1\x85\xd3\xae\xee\x7e\x10\x00\x01\x42\xc3\x00\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load8_u", [int64("-81_985_529_755_441_853")]), int64("67"))
>+
>+// memory.wast:223
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x93\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0b\x69\x36\x34\x5f\x6c\x6f\x61\x64\x38\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa2\x80\x80\x80\x00\x01\x9c\x80\x80\x80\x00\x00\x02\x40\x42\xef\x9b\xeb\xc5\xd9\xec\x90\xab\x34\x10\x00\x01\x42\xef\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load8_u", [int64("3_771_275_841_602_506_223")]), int64("239"))
>+
>+// memory.wast:224
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa3\x80\x80\x80\x00\x01\x9d\x80\x80\x80\x00\x00\x02\x40\x42\xc3\xca\xd1\xb1\x85\xd3\xae\xee\x7e\x10\x00\x01\x42\xc3\xca\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load16_s", [int64("-81_985_529_755_441_853")]), int64("25_923"))
>+
>+// memory.wast:225
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa3\x80\x80\x80\x00\x01\x9d\x80\x80\x80\x00\x00\x02\x40\x42\xef\x9b\xeb\xc5\xd9\xec\x90\xab\x34\x10\x00\x01\x42\xef\x9b\x7f\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load16_s", [int64("3_771_275_841_602_506_223")]), int64("-12_817"))
>+
>+// memory.wast:226
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa3\x80\x80\x80\x00\x01\x9d\x80\x80\x80\x00\x00\x02\x40\x42\xc3\xca\xd1\xb1\x85\xd3\xae\xee\x7e\x10\x00\x01\x42\xc3\xca\x01\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load16_u", [int64("-81_985_529_755_441_853")]), int64("25_923"))
>+
>+// memory.wast:227
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x31\x36\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa3\x80\x80\x80\x00\x01\x9d\x80\x80\x80\x00\x00\x02\x40\x42\xef\x9b\xeb\xc5\xd9\xec\x90\xab\x34\x10\x00\x01\x42\xef\x9b\x03\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load16_u", [int64("3_771_275_841_602_506_223")]), int64("52_719"))
>+
>+// memory.wast:228
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x42\xc3\xca\xd1\xb1\x85\xd3\xae\xee\x7e\x10\x00\x01\x42\xc3\xca\xd1\xb1\x05\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load32_s", [int64("-81_985_529_755_441_853")]), int64("1_446_274_371"))
>+
>+// memory.wast:229
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x73\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x42\xef\x9b\xeb\xc5\xd9\xec\x90\xab\x34\x10\x00\x01\x42\xef\x9b\xeb\xc5\x79\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load32_s", [int64("3_771_275_841_602_506_223")]), int64("-1_732_588_049"))
>+
>+// memory.wast:230
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x42\xc3\xca\xd1\xb1\x85\xd3\xae\xee\x7e\x10\x00\x01\x42\xc3\xca\xd1\xb1\x05\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load32_u", [int64("-81_985_529_755_441_853")]), int64("1_446_274_371"))
>+
>+// memory.wast:231
>+run(() => call(instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x00\x60\x01\x7e\x01\x7e\x02\x94\x80\x80\x80\x00\x01\x03\x24\x31\x32\x0c\x69\x36\x34\x5f\x6c\x6f\x61\x64\x33\x32\x5f\x75\x00\x01\x03\x82\x80\x80\x80\x00\x01\x00\x07\x87\x80\x80\x80\x00\x01\x03\x72\x75\x6e\x00\x01\x0a\xa5\x80\x80\x80\x00\x01\x9f\x80\x80\x80\x00\x00\x02\x40\x42\xef\x9b\xeb\xc5\xd9\xec\x90\xab\x34\x10\x00\x01\x42\xef\x9b\xeb\xc5\x09\x01\x51\x45\x0d\x00\x0f\x0b\x00\x0b", exports("$12", $12)),  "run", []));  // assert_return(() => call($12, "i64_load32_u", [int64("3_771_275_841_602_506_223")]), int64("2_562_379_247"))
>+
>+// memory.wast:235
>+assert_malformed("\x3c\x6d\x61\x6c\x66\x6f\x72\x6d\x65\x64\x20\x71\x75\x6f\x74\x65\x3e");
>+
>+// memory.wast:239
>+assert_malformed("\x3c\x6d\x61\x6c\x66\x6f\x72\x6d\x65\x64\x20\x71\x75\x6f\x74\x65\x3e");
>+
>+// memory.wast:243
>+assert_malformed("\x3c\x6d\x61\x6c\x66\x6f\x72\x6d\x65\x64\x20\x71\x75\x6f\x74\x65\x3e");
>diff --git a/JSTests/wasm/wasm.json b/JSTests/wasm/wasm.json
>index 947344e150c114562933377e35d5a8e416d00c23..3b8d2ca15083fc88c5455c661162ca2d5f77c20b 100644
>--- a/JSTests/wasm/wasm.json
>+++ b/JSTests/wasm/wasm.json
>@@ -223,6 +223,73 @@
>         "i32.reinterpret/f32": { "category": "conversion", "value": 188, "return": ["i32"],                          "parameter": ["f32"],                        "immediate": [], "b3op": "BitwiseCast"  },
>         "i64.reinterpret/f64": { "category": "conversion", "value": 189, "return": ["i64"],                          "parameter": ["f64"],                        "immediate": [], "b3op": "BitwiseCast"  },
>         "i32.extend8_s":       { "category": "conversion", "value": 192, "return": ["i32"],                          "parameter": ["i32"],                        "immediate": [], "b3op": "SExt8"        },
>-        "i32.extend16_s":      { "category": "conversion", "value": 193, "return": ["i32"],                          "parameter": ["i32"],                        "immediate": [], "b3op": "SExt16"       }
>+        "i32.extend16_s":      { "category": "conversion", "value": 193, "return": ["i32"],                          "parameter": ["i32"],                        "immediate": [], "b3op": "SExt16"       },
>+
>+        "memory.atomic.notify":       { "category": "atomic",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp":  0 },
>+        "memory.atomic.wait32":       { "category": "atomic",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp":  1 },
>+        "memory.atomic.wait64":       { "category": "atomic",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp":  2 },
>+        "i32.atomic.load":            { "category": "atomic.load",     "value": 254, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 16 },
>+        "i64.atomic.load":            { "category": "atomic.load",     "value": 254, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 17 },
>+        "i32.atomic.load8_u":         { "category": "atomic.load",     "value": 254, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 18 },
>+        "i32.atomic.load16_u":        { "category": "atomic.load",     "value": 254, "return": ["i32"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 19 },
>+        "i64.atomic.load8_u":         { "category": "atomic.load",     "value": 254, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 20 },
>+        "i64.atomic.load16_u":        { "category": "atomic.load",     "value": 254, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 21 },
>+        "i64.atomic.load32_u":        { "category": "atomic.load",     "value": 254, "return": ["i64"],      "parameter": ["addr"],                 "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 22 },
>+        "i32.atomic.store":           { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 23 },
>+        "i64.atomic.store":           { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 24 },
>+        "i32.atomic.store8_u":        { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 25 },
>+        "i32.atomic.store16_u":       { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 26 },
>+        "i64.atomic.store8_u":        { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 27 },
>+        "i64.atomic.store16_u":       { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 28 },
>+        "i64.atomic.store32_u":       { "category": "atomic.store",     "value": 254, "return": [],           "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 29 },
>+        "i32.atomic.rmw.add":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 30 },
>+        "i64.atomic.rmw.add":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 31 },
>+        "i32.atomic.rmw8.add_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 32 },
>+        "i32.atomic.rmw16.add_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 33 },
>+        "i64.atomic.rmw8.add_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 34 },
>+        "i64.atomic.rmw16.add_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 35 },
>+        "i64.atomic.rmw32.add_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 36 },
>+        "i32.atomic.rmw.sub":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 37 },
>+        "i64.atomic.rmw.sub":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 38 },
>+        "i32.atomic.rmw8.sub_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 39 },
>+        "i32.atomic.rmw16.sub_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 40 },
>+        "i64.atomic.rmw8.sub_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 41 },
>+        "i64.atomic.rmw16.sub_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 42 },
>+        "i64.atomic.rmw32.sub_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 43 },
>+        "i32.atomic.rmw.and":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 44 },
>+        "i64.atomic.rmw.and":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 45 },
>+        "i32.atomic.rmw8.and_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 46 },
>+        "i32.atomic.rmw16.and_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 47 },
>+        "i64.atomic.rmw8.and_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 48 },
>+        "i64.atomic.rmw16.and_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 49 },
>+        "i64.atomic.rmw32.and_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 50 },
>+        "i32.atomic.rmw.or":          { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 51 },
>+        "i64.atomic.rmw.or":          { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 52 },
>+        "i32.atomic.rmw8.or_u":       { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 53 },
>+        "i32.atomic.rmw16.or_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 54 },
>+        "i64.atomic.rmw8.or_u":       { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 55 },
>+        "i64.atomic.rmw16.or_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 56 },
>+        "i64.atomic.rmw32.or_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 57 },
>+        "i32.atomic.rmw.xor":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 58 },
>+        "i64.atomic.rmw.xor":         { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 59 },
>+        "i32.atomic.rmw8.xor_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 60 },
>+        "i32.atomic.rmw16.xor_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 61 },
>+        "i64.atomic.rmw8.xor_u":      { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 62 },
>+        "i64.atomic.rmw16.xor_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 63 },
>+        "i64.atomic.rmw32.xor_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 64 },
>+        "i32.atomic.rmw.xchg":        { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 65 },
>+        "i64.atomic.rmw.xchg":        { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 66 },
>+        "i32.atomic.rmw8.xchg_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 67 },
>+        "i32.atomic.rmw16.xchg_u":    { "category": "atomic.rmw.binary",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 68 },
>+        "i64.atomic.rmw8.xchg_u":     { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 69 },
>+        "i64.atomic.rmw16.xchg_u":    { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 70 },
>+        "i64.atomic.rmw32.xchg_u":    { "category": "atomic.rmw.binary",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64"],          "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 71 },
>+        "i32.atomic.rmw.cmpxchg":     { "category": "atomic.rmw",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32", "i32"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 72 },
>+        "i64.atomic.rmw.cmpxchg":     { "category": "atomic.rmw",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 73 },
>+        "i32.atomic.rmw8.cmpxchg_u":  { "category": "atomic.rmw",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32", "i32"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 74 },
>+        "i32.atomic.rmw16.cmpxchg_u": { "category": "atomic.rmw",     "value": 254, "return": ["i32"],      "parameter": ["addr", "i32", "i32"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 75 },
>+        "i64.atomic.rmw8.cmpxchg_u":  { "category": "atomic.rmw",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 76 },
>+        "i64.atomic.rmw16.cmpxchg_u": { "category": "atomic.rmw",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 77 },
>+        "i64.atomic.rmw32.cmpxchg_u": { "category": "atomic.rmw",     "value": 254, "return": ["i64"],      "parameter": ["addr", "i64", "i64"],   "immediate": [{"name": "flags",          "type": "varuint32"}, {"name": "offset",   "type": "varuint32"}], "extendedOp": 78 }
>     }
> }

Actions: View | Formatted Diff | Diff

Attachments on bug 218954: 414545 | 414747 | 414750 | 414752 | 414753 | 414758 | 414771 | 414785 | 414795 | 414818 | 414826 | 414827 | 414828 | 414829 | 414830 | 414851 | 414858 | 414867 | 414911