Attachment #415968 for bug #219297

View Details Raw Unified Return to Bug 219297

| Differences between



2020-12-08  Dmitry Bezhetskov  <dbezhetskov@igalia.com>

        [WASM-References] Add table.init
        https://bugs.webkit.org/show_bug.cgi?id=219297

        Reviewed by NOBODY (OOPS!).

        Add support for table.init, elem.drop and new element section
        from reference-type proposal: 
        https://webassembly.github.io/reference-types/core/syntax/instructions.html#table-instructions,
        https://webassembly.github.io/reference-types/core/syntax/modules.html#element-segments.
        All in one patch because all this stuff are very coupled and ref-types
        spec tests require each other to run the its tests, so not to write
        hand-crafted tests this is in one PR.

        * bytecode/BytecodeList.rb:
        * llint/WebAssembly.asm:
        * wasm/WasmAirIRGenerator.cpp:
        (JSC::Wasm::AirIRGenerator::addTableInit):
        (JSC::Wasm::AirIRGenerator::addElemDrop):
        * wasm/WasmB3IRGenerator.cpp:
        (JSC::Wasm::B3IRGenerator::addTableInit):
        (JSC::Wasm::B3IRGenerator::addElemDrop):
        * wasm/WasmFormat.h:
        (JSC::Wasm::Element::Element):
        (JSC::Wasm::Element::length const):
        (JSC::Wasm::Element::isPassive const):
        * wasm/WasmFunctionParser.h:
        (JSC::Wasm::FunctionParser<Context>::parseExpression):
        * wasm/WasmInstance.cpp:
        (JSC::Wasm::Instance::Instance):
        (JSC::Wasm::Instance::elemDrop):
        (JSC::Wasm::Instance::elem const):
        (JSC::Wasm::Instance::initElementSegment):
        (JSC::Wasm::Instance::tableInit):
        * wasm/WasmInstance.h:
        (JSC::Wasm::Instance::isImportFunction const):
        * wasm/WasmLLIntGenerator.cpp:
        (JSC::Wasm::LLIntGenerator::addTableInit):
        (JSC::Wasm::LLIntGenerator::addElemDrop):
        * wasm/WasmModuleInformation.h:
        (JSC::Wasm::ModuleInformation::elementCount const):
        * wasm/WasmOperations.cpp:
        (JSC::Wasm::JSC_DEFINE_JIT_OPERATION):
        * wasm/WasmOperations.h:
        * wasm/WasmSectionParser.cpp:
        (JSC::Wasm::SectionParser::parseElement):
        (JSC::Wasm::SectionParser::parseElementSegmentVectorOfExpressions):
        (JSC::Wasm::SectionParser::parseElementSegmentVectorOfIndexes):
        (JSC::Wasm::SectionParser::parseFuncIndexFromRefExpForElementSection): Deleted.
        (JSC::Wasm::SectionParser::parseFuncIndexForElementSection): Deleted.
        * wasm/WasmSectionParser.h:
        * wasm/WasmSlowPaths.cpp:
        (JSC::LLInt::WASM_SLOW_PATH_DECL):
        * wasm/WasmSlowPaths.h:
        * wasm/js/WebAssemblyModuleRecord.cpp:
        (JSC::WebAssemblyModuleRecord::evaluate):
        * wasm/wasm.json:

2020-12-07  Dmitry Bezhetskov  <dbezhetskov@igalia.com>

        [WASM-References] Add support for table.copy



        tableIndex: unsigned,
    }

op :table_init,
    args: {
        dstOffset: VirtualRegister,
        srcOffset: VirtualRegister,
        length: VirtualRegister,
        elementIndex: unsigned,
        tableIndex: unsigned,
    }

op :elem_drop,
    args: {
        elementIndex: unsigned,
    }

op :table_size,
    args: {
        dst: VirtualRegister,

Lines 561-566 noWide(wasm_wide32) a/Source/JavaScriptCore/llint/WebAssembly.asm_sec1
- a/Source/JavaScriptCore/llint/WebAssembly.asm +2 lines
561	slowWasmOp(ref_func)	561	slowWasmOp(ref_func)
562	slowWasmOp(table_get)	562	slowWasmOp(table_get)
563	slowWasmOp(table_set)	563	slowWasmOp(table_set)
		564	slowWasmOp(table_init)
		565	slowWasmOp(elem_drop)
564	slowWasmOp(table_size)	566	slowWasmOp(table_size)
565	slowWasmOp(table_fill)	567	slowWasmOp(table_fill)
566	slowWasmOp(table_copy)	568	slowWasmOp(table_copy)



    // Tables
    PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);
    PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);
    PartialResult WARN_UNUSED_RETURN addTableInit(unsigned, unsigned, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length);
    PartialResult WARN_UNUSED_RETURN addElemDrop(unsigned);
    PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);
    PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);
    PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);

    return { };
}

auto AirIRGenerator::addTableInit(unsigned elementIndex, unsigned tableIndex, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length) -> PartialResult
{
    ASSERT(dstOffset.tmp());
    ASSERT(dstOffset.type() == Type::I32);

    ASSERT(srcOffset.tmp());
    ASSERT(srcOffset.type() == Type::I32);

    ASSERT(length.tmp());
    ASSERT(length.type() == Type::I32);

    auto result = tmpForType(Type::I32);
    emitCCall(
        &operationWasmTableInit, result, instanceValue(),
        addConstant(Type::I32, elementIndex),
        addConstant(Type::I32, tableIndex),
        dstOffset, srcOffset, length);

    emitCheck([&] {
        return Inst(BranchTest32, nullptr, Arg::resCond(MacroAssembler::Zero), result, result);
    }, [=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
        this->emitThrowException(jit, ExceptionType::OutOfBoundsTableAccess);
    });

    return { };
}

auto AirIRGenerator::addElemDrop(unsigned elementIndex) -> PartialResult
{
    emitCCall(&operationWasmElemDrop, TypedTmp(), instanceValue(), addConstant(Type::I32, elementIndex));
    return { };
}

auto AirIRGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult
{
    // FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.



    // Tables
    PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);
    PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);
    PartialResult WARN_UNUSED_RETURN addTableInit(unsigned, unsigned, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length);
    PartialResult WARN_UNUSED_RETURN addElemDrop(unsigned);
    PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);
    PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);
    PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);

    return { };
}

auto B3IRGenerator::addTableInit(unsigned elementIndex, unsigned tableIndex, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length) -> PartialResult
{
    auto result = m_currentBlock->appendNew<CCallValue>(
        m_proc, toB3Type(I32), origin(),
        m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmTableInit)),
        instanceValue(),
        m_currentBlock->appendNew<Const32Value>(m_proc, origin(), elementIndex),
        m_currentBlock->appendNew<Const32Value>(m_proc, origin(), tableIndex),
        dstOffset, srcOffset, length);

    {
        CheckValue* check = m_currentBlock->appendNew<CheckValue>(m_proc, Check, origin(),
            m_currentBlock->appendNew<Value>(m_proc, Equal, origin(), result, m_currentBlock->appendNew<Const32Value>(m_proc, origin(), 0)));

        check->setGenerator([=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
            this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsTableAccess);
        });
    }

    return { };
}

auto B3IRGenerator::addElemDrop(unsigned elementIndex) -> PartialResult
{
    m_currentBlock->appendNew<CCallValue>(
        m_proc, B3::Void, origin(),
        m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmElemDrop)),
        instanceValue(),
        m_currentBlock->appendNew<Const32Value>(m_proc, origin(), elementIndex));

    return { };
}

auto B3IRGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult
{
    // FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.



        Declared,
    };

    Element(Element::Kind kind, TableElementType elementType, Optional<uint32_t> tableIndex, Optional<I32InitExpr> initExpr)
        : kind(kind)
        , elementType(elementType)
        , tableIndexIfActive(WTFMove(tableIndex))
        , offsetIfActive(WTFMove(initExpr))
    { }

    Element(Element::Kind kind, TableElementType elemType)
        : Element(kind, elemType, WTF::nullopt, WTF::nullopt)
    { }

    uint32_t length() const { return functionIndices.size(); }

    bool isActive() const { return kind == Kind::Active; }
    bool isPassive() const { return kind == Kind::Passive; }

    static bool isNullFuncIndex(uint32_t idx) { return idx == nullFuncIndex; }

    Kind kind;
    TableElementType elementType;
    Optional<uint32_t> tableIndexIfActive;
    Optional<I32InitExpr> offsetIfActive;

    // Index may be nullFuncIndex.



    PartialResult WARN_UNUSED_RETURN atomicNotify(ExtAtomicOpType);
    PartialResult WARN_UNUSED_RETURN atomicFence(ExtAtomicOpType);

    PartialResult WARN_UNUSED_RETURN parseTableIndex(unsigned&);
    PartialResult WARN_UNUSED_RETURN parseElementIndex(unsigned&);

    struct TableInitImmediates {
        unsigned elementIndex;
        unsigned tableIndex;
    };
    PartialResult WARN_UNUSED_RETURN parseTableInitImmediates(TableInitImmediates&);

    struct TableCopyImmediates {
        unsigned srcTableIndex;
        unsigned dstTableIndex;
    };
    PartialResult WARN_UNUSED_RETURN parseTableCopyImmediates(TableCopyImmediates&);

#define WASM_TRY_ADD_TO_CONTEXT(add_expression) WASM_FAIL_IF_HELPER_FAILS(m_context.add_expression)

    template <typename ...Args>

    return { };
}

template<typename Context>
auto FunctionParser<Context>::parseTableIndex(unsigned& result) -> PartialResult
{
    unsigned tableIndex;
    WASM_PARSER_FAIL_IF(!parseVarUInt32(tableIndex), "can't parse table index");
    WASM_VALIDATOR_FAIL_IF(tableIndex >= m_info.tableCount(), "table index ", tableIndex, " is invalid, limit is ", m_info.tableCount());
    result = tableIndex;
    return { };
}

template<typename Context>
auto FunctionParser<Context>::parseElementIndex(unsigned& result) -> PartialResult
{
    unsigned elementIndex;
    WASM_PARSER_FAIL_IF(!parseVarUInt32(elementIndex), "can't parse element index");
    WASM_VALIDATOR_FAIL_IF(elementIndex >= m_info.elementCount(), "element index ", elementIndex, " is invalid, limit is ", m_info.elementCount());
    result = elementIndex;
    return { };
}

template<typename Context>
auto FunctionParser<Context>::parseTableInitImmediates(TableInitImmediates& result) -> PartialResult
{
    unsigned elementIndex;
    WASM_FAIL_IF_HELPER_FAILS(parseElementIndex(elementIndex));

    unsigned tableIndex;
    WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));

    result.elementIndex = elementIndex;
    result.tableIndex = tableIndex;

    return { };
}

template<typename Context>
auto FunctionParser<Context>::parseTableCopyImmediates(TableCopyImmediates& result) -> PartialResult
{
    unsigned dstTableIndex;
    WASM_PARSER_FAIL_IF(!parseVarUInt32(dstTableIndex), "can't parse destination table index");
    WASM_VALIDATOR_FAIL_IF(dstTableIndex >= m_info.tableCount(), "table index ", dstTableIndex, " is invalid, limit is ", m_info.tableCount());

    unsigned srcTableIndex;
    WASM_PARSER_FAIL_IF(!parseVarUInt32(srcTableIndex), "can't parse source table index");
    WASM_VALIDATOR_FAIL_IF(srcTableIndex >= m_info.tableCount(), "table index ", srcTableIndex, " is invalid, limit is ", m_info.tableCount());

    result.dstTableIndex = dstTableIndex;
    result.srcTableIndex = srcTableIndex;

    return { };
}

template<typename Context>
auto FunctionParser<Context>::checkBranchTarget(const ControlType& target) -> PartialResult
{

        WASM_PARSER_FAIL_IF(!parseUInt8(extOp), "can't parse table extended opcode");

        switch (static_cast<ExtTableOpType>(extOp)) {
        case ExtTableOpType::TableInit: {
            TableInitImmediates immediates;
            WASM_FAIL_IF_HELPER_FAILS(parseTableInitImmediates(immediates));

            TypedExpression dstOffset;
            TypedExpression srcOffset;
            TypedExpression lenght;
            WASM_TRY_POP_EXPRESSION_STACK_INTO(lenght, "table.init");
            WASM_TRY_POP_EXPRESSION_STACK_INTO(srcOffset, "table.init");
            WASM_TRY_POP_EXPRESSION_STACK_INTO(dstOffset, "table.init");

            WASM_VALIDATOR_FAIL_IF(I32 != dstOffset.type(), "table.init dst_offset to type ", dstOffset.type(), " expected ", I32);
            WASM_VALIDATOR_FAIL_IF(I32 != srcOffset.type(), "table.init src_offset to type ", srcOffset.type(), " expected ", I32);
            WASM_VALIDATOR_FAIL_IF(I32 != lenght.type(), "table.init length to type ", lenght.type(), " expected ", I32);

            WASM_TRY_ADD_TO_CONTEXT(addTableInit(immediates.elementIndex, immediates.tableIndex, dstOffset, srcOffset, lenght));
            break;
        }
        case ExtTableOpType::ElemDrop: {
            unsigned elementIndex;
            WASM_FAIL_IF_HELPER_FAILS(parseElementIndex(elementIndex));

            WASM_TRY_ADD_TO_CONTEXT(addElemDrop(elementIndex));
            break;
        }
        case ExtTableOpType::TableSize: {
            unsigned tableIndex;
            WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
            WASM_VALIDATOR_FAIL_IF(tableIndex >= m_info.tableCount(), "table index ", tableIndex, " is invalid, limit is ", m_info.tableCount());

            ExpressionType result;
            WASM_TRY_ADD_TO_CONTEXT(addTableSize(tableIndex, result));

        }
        case ExtTableOpType::TableGrow: {
            unsigned tableIndex;
            WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
            WASM_VALIDATOR_FAIL_IF(tableIndex >= m_info.tableCount(), "table index ", tableIndex, " is invalid, limit is ", m_info.tableCount());

            TypedExpression fill;
            TypedExpression delta;

        }
        case ExtTableOpType::TableFill: {
            unsigned tableIndex;
            WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
            WASM_VALIDATOR_FAIL_IF(tableIndex >= m_info.tableCount(), "table index ", tableIndex, " is invalid, limit is ", m_info.tableCount());

            TypedExpression offset, fill, count;
            WASM_TRY_POP_EXPRESSION_STACK_INTO(count, "table.fill");

            break;
        }
        case ExtTableOpType::TableCopy: {
            TableCopyImmediates immediates;
            WASM_FAIL_IF_HELPER_FAILS(parseTableCopyImmediates(immediates));
            WASM_VALIDATOR_FAIL_IF(dstTableIndex >= m_info.tableCount(), "table index ", dstTableIndex, " is invalid, limit is ", m_info.tableCount());

            unsigned srcTableIndex;
            WASM_PARSER_FAIL_IF(!parseVarUInt32(srcTableIndex), "can't parse source table index");
            WASM_VALIDATOR_FAIL_IF(srcTableIndex >= m_info.tableCount(), "table index ", srcTableIndex, " is invalid, limit is ", m_info.tableCount());

            const auto srcType = m_info.table(immediates.srcTableIndex).wasmType();
            const auto dstType = m_info.table(immediates.dstTableIndex).wasmType();
            WASM_VALIDATOR_FAIL_IF(srcType != dstType, "type mismatch at table.copy. got ", srcType, " and ", dstType);

            TypedExpression dstOffset;

            WASM_VALIDATOR_FAIL_IF(I32 != srcOffset.type(), "table.copy src_offset to type ", srcOffset.type(), " expected ", I32);
            WASM_VALIDATOR_FAIL_IF(I32 != length.type(), "table.copy length to type ", length.type(), " expected ", I32);

            WASM_TRY_ADD_TO_CONTEXT(addTableCopy(immediates.dstTableIndex, immediates.srcTableIndex, dstOffset, srcOffset, length));
            break;
        }
        default:

        return { };
    }

    case ExtTable: {
        WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");
        uint8_t extOp;
        WASM_PARSER_FAIL_IF(!parseUInt8(extOp), "can't parse table extended opcode");

        switch (static_cast<ExtTableOpType>(extOp)) {
        case ExtTableOpType::TableInit: {
            TableInitImmediates immediates;
            WASM_FAIL_IF_HELPER_FAILS(parseTableInitImmediates(immediates));
            return { };
        }
        case ExtTableOpType::ElemDrop: {
            unsigned elementIndex;
            WASM_FAIL_IF_HELPER_FAILS(parseElementIndex(elementIndex));
            return { };
        }
        case ExtTableOpType::TableSize:
        case ExtTableOpType::TableGrow:
        case ExtTableOpType::TableFill: {
            unsigned tableIndex;
            WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
            return { };
        }
        case ExtTableOpType::TableCopy: {
            TableCopyImmediates immediates;
            WASM_FAIL_IF_HELPER_FAILS(parseTableCopyImmediates(immediates));
            return { };
        }
        default:
            WASM_PARSER_FAIL_IF(true, "invalid extended table op ", extOp);
            break;
        }

        return { };
    }

    case TableGet:
    case TableSet: {
        unsigned tableIndex;

Lines 32-37 a/Source/JavaScriptCore/wasm/WasmInstance.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmInstance.cpp +100 lines
32	#include "JSWebAssemblyInstance.h"	32	#include "JSWebAssemblyInstance.h"
33	#include "Register.h"	33	#include "Register.h"
34	#include "WasmModuleInformation.h"	34	#include "WasmModuleInformation.h"
		35	#include "WasmSignatureInlines.h"
35	#include <wtf/CheckedArithmetic.h>	36	#include <wtf/CheckedArithmetic.h>
36		37
37	namespace JSC { namespace Wasm {	38	namespace JSC { namespace Wasm {
Lines 53-58 Instance::Instance(Context* context, Ref<Module>&& module, EntryFrame** pointerT a/Source/JavaScriptCore/wasm/WasmInstance.cpp_sec2
53	, m_pointerToActualStackLimit(pointerToActualStackLimit)	54	, m_pointerToActualStackLimit(pointerToActualStackLimit)
54	, m_storeTopCallFrame(WTFMove(storeTopCallFrame))	55	, m_storeTopCallFrame(WTFMove(storeTopCallFrame))
55	, m_numImportFunctions(m_module->moduleInformation().importFunctionCount())	56	, m_numImportFunctions(m_module->moduleInformation().importFunctionCount())
		57	, m_passiveElements(m_module->moduleInformation().elementCount())
56	{	58	{
57	for (unsigned i = 0; i < m_numImportFunctions; ++i)	59	for (unsigned i = 0; i < m_numImportFunctions; ++i)
58	new (importFunctionInfo(i)) ImportFunctionInfo();	60	new (importFunctionInfo(i)) ImportFunctionInfo();
Lines 68-73 Instance::Instance(Context* context, Ref<Module>&& module, EntryFrame** pointerT a/Source/JavaScriptCore/wasm/WasmInstance.cpp_sec3
68	}	70	}
69	}	71	}
70	memset(bitwise_cast<char>(this) + offsetOfTablePtr(m_numImportFunctions, 0), 0, m_module->moduleInformation().tableCount() sizeof(Table*));	72	memset(bitwise_cast<char>(this) + offsetOfTablePtr(m_numImportFunctions, 0), 0, m_module->moduleInformation().tableCount() sizeof(Table*));
		73	for (unsigned elementIndex = 0; elementIndex < m_module->moduleInformation().elementCount(); ++elementIndex) {
		74	const auto& element = m_module->moduleInformation().elements[elementIndex];
		75	if (element.isPassive())
		76	m_passiveElements.quickSet(elementIndex);
		77	}
71	}	78	}
72		79
73	Ref<Instance> Instance::create(Context* context, Ref<Module>&& module, EntryFrame pointerToTopEntryFrame, void pointerToActualStackLimit, StoreTopCallFrameCallback&& storeTopCallFrame)	80	Ref<Instance> Instance::create(Context* context, Ref<Module>&& module, EntryFrame pointerToTopEntryFrame, void pointerToActualStackLimit, StoreTopCallFrameCallback&& storeTopCallFrame)
Lines 153-158 void Instance::tableCopy(uint32_t dstOffset, uint32_t srcOffset, uint32_t length a/Source/JavaScriptCore/wasm/WasmInstance.cpp_sec4
153	});	160	});
154	}	161	}
155		162
		163	void Instance::elemDrop(uint32_t elementIndex)
		164	{
		165	m_passiveElements.quickClear(elementIndex);
		166	}
		167
		168	const Element* Instance::elementAt(unsigned index) const
		169	{
		170	RELEASE_ASSERT(index < m_module->moduleInformation().elementCount());
		171
		172	if (m_passiveElements.quickGet(index))
		173	return &m_module->moduleInformation().elements[index];
		174	return nullptr;
		175	}
		176
		177	void Instance::initElementSegment(uint32_t tableIndex, const Element& segment, uint32_t dstOffset, uint32_t srcOffset, uint32_t length)
		178	{
		179	RELEASE_ASSERT(length <= segment.length());
		180
		181	JSWebAssemblyInstance* jsInstance = owner<JSWebAssemblyInstance>();
		182	JSWebAssemblyTable* jsTable = jsInstance->table(tableIndex);
		183	JSGlobalObject* globalObject = jsInstance->globalObject();
		184	VM& vm = globalObject->vm();
		185
		186	for (uint32_t index = 0; index < length; ++index) {
		187	const auto srcIndex = srcOffset + index;
		188	const auto dstIndex = dstOffset + index;
		189
		190	if (Element::isNullFuncIndex(segment.functionIndices[srcIndex])) {
		191	jsTable->clear(dstIndex);
		192	continue;
		193	}
		194
		195	// FIXME: This essentially means we're exporting an import.
		196	// We need a story here. We need to create a WebAssemblyFunction
		197	// for the import.
		198	// https://bugs.webkit.org/show_bug.cgi?id=165510
		199	uint32_t functionIndex = segment.functionIndices[srcIndex];
		200	SignatureIndex signatureIndex = m_module->signatureIndexFromFunctionIndexSpace(functionIndex);
		201	if (isImportFunction(functionIndex)) {
		202	JSObject* functionImport = importFunction<WriteBarrier<JSObject>>(functionIndex)->get();
		203	if (isWebAssemblyHostFunction(vm, functionImport)) {
		204	WebAssemblyFunction* wasmFunction = jsDynamicCast<WebAssemblyFunction*>(vm, functionImport);
		205	// If we ever import a WebAssemblyWrapperFunction, we set the import as the unwrapped value.
		206	// Because a WebAssemblyWrapperFunction can never wrap another WebAssemblyWrapperFunction,
		207	// the only type this could be is WebAssemblyFunction.
		208	RELEASE_ASSERT(wasmFunction);
		209	jsTable->set(dstIndex, wasmFunction);
		210	continue;
		211	}
		212	auto* wrapperFunction = WebAssemblyWrapperFunction::create(
		213	vm,
		214	globalObject,
		215	globalObject->webAssemblyWrapperFunctionStructure(),
		216	functionImport,
		217	functionIndex,
		218	jsInstance,
		219	signatureIndex);
		220	jsTable->set(dstIndex, wrapperFunction);
		221	continue;
		222	}
		223
		224	Callee& embedderEntrypointCallee = codeBlock()->embedderEntrypointCalleeFromFunctionIndexSpace(functionIndex);
		225	WasmToWasmImportableFunction::LoadLocation entrypointLoadLocation = codeBlock()->entrypointLoadLocationFromFunctionIndexSpace(functionIndex);
		226	const Signature& signature = SignatureInformation::get(signatureIndex);
227	// FIXME: Say we export local function "foo" at function index 0.
228	// What if we also set it to the table an Element w/ index 0.
229	// Does (new Instance(...)).exports.foo === table.get(0)?
230	// https://bugs.webkit.org/show_bug.cgi?id=165825
231	WebAssemblyFunction* function = WebAssemblyFunction::create(
232	vm,
233	globalObject,
234	globalObject->webAssemblyFunctionStructure(),
235	signature.argumentCount(),
236	String(),
237	jsInstance,
238	embedderEntrypointCallee,
239	entrypointLoadLocation,
240	signatureIndex);
241	jsTable->set(dstIndex, function);
242	}
243	}
244
245	void Instance::tableInit(uint32_t dstOffset, uint32_t srcOffset, uint32_t length, uint32_t elementIndex, uint32_t tableIndex)
246	{
247	RELEASE_ASSERT(elementIndex < m_module->moduleInformation().elementCount());
248	RELEASE_ASSERT(tableIndex < m_module->moduleInformation().tableCount());
249
250	const Element* elementSegment = elementAt(elementIndex);
251	RELEASE_ASSERT(elementSegment);
252	RELEASE_ASSERT(elementSegment->isPassive());
253	initElementSegment(tableIndex, *elementSegment, dstOffset, srcOffset, length);
254	}
255
156	void Instance::setTable(unsigned i, Ref<Table>&& table)	256	void Instance::setTable(unsigned i, Ref<Table>&& table)
157	{	257	{
158	RELEASE_ASSERT(i < m_module->moduleInformation().tableCount());	258	RELEASE_ASSERT(i < m_module->moduleInformation().tableCount());

Lines 76-84 public: a/Source/JavaScriptCore/wasm/WasmInstance.h_sec1
- a/Source/JavaScriptCore/wasm/WasmInstance.h +13 lines
76	Memory* memory() { return m_memory.get(); }	76	Memory* memory() { return m_memory.get(); }
77	Table* table(unsigned);	77	Table* table(unsigned);
78	void setTable(unsigned, Ref<Table>&&);	78	void setTable(unsigned, Ref<Table>&&);
		79	const Element* elementAt(unsigned) const;
		80
		81	void initElementSegment(uint32_t tableIndex, const Element& segment, uint32_t dstOffset, uint32_t srcOffset, uint32_t length);
		82
		83	bool isImportFunction(uint32_t functionIndex) const
		84	{
		85	return functionIndex < m_codeBlock->functionImportCount();
		86	}
		87
		88	void tableInit(uint32_t dstOffset, uint32_t srcOffset, uint32_t length, uint32_t elementIndex, uint32_t tableIndex);
79		89
80	void tableCopy(uint32_t dstOffset, uint32_t srcOffset, uint32_t length, uint32_t dstTableIndex, uint32_t srcTableIndex);	90	void tableCopy(uint32_t dstOffset, uint32_t srcOffset, uint32_t length, uint32_t dstTableIndex, uint32_t srcTableIndex);
81		91
		92	void elemDrop(uint32_t elementIndex);
		93
82	void* cachedMemory() const { return m_cachedMemory.getMayBeNull(cachedBoundsCheckingSize()); }	94	void* cachedMemory() const { return m_cachedMemory.getMayBeNull(cachedBoundsCheckingSize()); }
83	size_t cachedBoundsCheckingSize() const { return m_cachedBoundsCheckingSize; }	95	size_t cachedBoundsCheckingSize() const { return m_cachedBoundsCheckingSize; }
84		96
Lines 218-223 private: a/Source/JavaScriptCore/wasm/WasmInstance.h_sec2
218	StoreTopCallFrameCallback m_storeTopCallFrame;	230	StoreTopCallFrameCallback m_storeTopCallFrame;
219	unsigned m_numImportFunctions { 0 };	231	unsigned m_numImportFunctions { 0 };
220	HashMap<uint32_t, Ref<Global>, IntHash<uint32_t>, WTF::UnsignedWithZeroKeyHashTraits<uint32_t>> m_linkedGlobals;	232	HashMap<uint32_t, Ref<Global>, IntHash<uint32_t>, WTF::UnsignedWithZeroKeyHashTraits<uint32_t>> m_linkedGlobals;
		233	BitVector m_passiveElements;
221	};	234	};
222		235
223	} } // namespace JSC::Wasm	236	} } // namespace JSC::Wasm

Lines 191-196 public: a/Source/JavaScriptCore/wasm/WasmLLIntGenerator.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmLLIntGenerator.cpp +16 lines
191	// Tables	191	// Tables
192	PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);	192	PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);
193	PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);	193	PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);
		194	PartialResult WARN_UNUSED_RETURN addTableInit(unsigned, unsigned, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length);
		195	PartialResult WARN_UNUSED_RETURN addElemDrop(unsigned);
194	PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);	196	PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);
195	PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);	197	PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);
196	PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);	198	PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);
Lines 1119-1124 auto LLIntGenerator::addTableSet(unsigned tableIndex, ExpressionType index, Expr a/Source/JavaScriptCore/wasm/WasmLLIntGenerator.cpp_sec2
1119	return { };	1121	return { };
1120	}	1122	}
1121		1123
		1124	auto LLIntGenerator::addTableInit(unsigned elementIndex, unsigned tableIndex, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length) -> PartialResult
		1125	{
		1126	WasmTableInit::emit(this, dstOffset, srcOffset, length, elementIndex, tableIndex);
		1127
		1128	return { };
		1129	}
		1130
		1131	auto LLIntGenerator::addElemDrop(unsigned elementIndex) -> PartialResult
		1132	{
		1133	WasmElemDrop::emit(this, elementIndex);
		1134
		1135	return { };
		1136	}
		1137
1122	auto LLIntGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult	1138	auto LLIntGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult
1123	{	1139	{
1124	result = push();	1140	result = push();

Lines 66-71 struct ModuleInformation : public ThreadSafeRefCounted<ModuleInformation> { a/Source/JavaScriptCore/wasm/WasmModuleInformation.h_sec1
- a/Source/JavaScriptCore/wasm/WasmModuleInformation.h +1 lines
66	// If we need to remove this limitation, we would have MemoryInformation and TableInformation in the Vectors.	66	// If we need to remove this limitation, we would have MemoryInformation and TableInformation in the Vectors.
67	uint32_t memoryCount() const { return memory ? 1 : 0; }	67	uint32_t memoryCount() const { return memory ? 1 : 0; }
68	uint32_t tableCount() const { return tables.size(); }	68	uint32_t tableCount() const { return tables.size(); }
		69	uint32_t elementCount() const { return elements.size(); }
69		70
70	const TableInformation& table(unsigned index) const { return tables[index]; }	71	const TableInformation& table(unsigned index) const { return tables[index]; }
71		72



    return setWasmTableElement(instance, tableIndex, signedIndex, encValue);
}

JSC_DEFINE_JIT_OPERATION(operationWasmTableInit, bool, (Instance* instance, unsigned elementIndex, unsigned tableIndex, int32_t dstOffset, int32_t srcOffset, int32_t length))
{
    ASSERT(elementIndex < instance->module().moduleInformation().elementCount());
    ASSERT(tableIndex < instance->module().moduleInformation().tableCount());

    if ((srcOffset < 0) || (dstOffset < 0) || (length < 0))
        return false;

    Checked<uint32_t, RecordOverflow> lastSrcElementIndexChecked = static_cast<uint32_t>(srcOffset);
    lastSrcElementIndexChecked += static_cast<uint32_t>(length);

    uint32_t lastSrcElementIndex;
    if (lastSrcElementIndexChecked.safeGet(lastSrcElementIndex) == CheckedState::DidOverflow)
        return false;

    if (!instance->elementAt(elementIndex) || lastSrcElementIndex > instance->elementAt(elementIndex)->length())
        return false;

    Checked<uint32_t, RecordOverflow> lastDstElementIndexChecked = static_cast<uint32_t>(dstOffset);
    lastDstElementIndexChecked += static_cast<uint32_t>(length);

    uint32_t lastDstElementIndex;
    if (lastDstElementIndexChecked.safeGet(lastDstElementIndex) == CheckedState::DidOverflow)
        return false;

    if (lastDstElementIndex > instance->table(tableIndex)->length())
        return false;

    instance->tableInit(dstOffset, srcOffset, length, elementIndex, tableIndex);
    return true;
}

JSC_DEFINE_JIT_OPERATION(operationWasmElemDrop, void, (Instance* instance, unsigned elementIndex))
{
    ASSERT(elementIndex < instance->module().moduleInformation().elementCount());
    instance->elemDrop(elementIndex);
}

JSC_DEFINE_JIT_OPERATION(operationWasmTableGrow, int32_t, (Instance* instance, unsigned tableIndex, EncodedJSValue fill, int32_t delta))
{
    ASSERT(tableIndex < instance->module().moduleInformation().tableCount());

Lines 65-70 JSC_DECLARE_JIT_OPERATION(operationGrowMemory, int32_t, (void, Instance, int32 a/Source/JavaScriptCore/wasm/WasmOperations.h_sec1
- a/Source/JavaScriptCore/wasm/WasmOperations.h +2 lines
65	JSC_DECLARE_JIT_OPERATION(operationGetWasmTableElement, EncodedJSValue, (Instance*, unsigned, int32_t));	65	JSC_DECLARE_JIT_OPERATION(operationGetWasmTableElement, EncodedJSValue, (Instance*, unsigned, int32_t));
66	JSC_DECLARE_JIT_OPERATION(operationSetWasmTableElement, bool, (Instance*, unsigned, int32_t, EncodedJSValue encValue));	66	JSC_DECLARE_JIT_OPERATION(operationSetWasmTableElement, bool, (Instance*, unsigned, int32_t, EncodedJSValue encValue));
67	JSC_DECLARE_JIT_OPERATION(operationWasmRefFunc, EncodedJSValue, (Instance*, uint32_t));	67	JSC_DECLARE_JIT_OPERATION(operationWasmRefFunc, EncodedJSValue, (Instance*, uint32_t));
		68	JSC_DECLARE_JIT_OPERATION(operationWasmTableInit, bool, (Instance*, unsigned elementIndex, unsigned tableIndex, int32_t dstOffset, int32_t srcOffset, int32_t length));
		69	JSC_DECLARE_JIT_OPERATION(operationWasmElemDrop, void, (Instance*, unsigned elementIndex));
68	JSC_DECLARE_JIT_OPERATION(operationWasmTableGrow, int32_t, (Instance*, unsigned, EncodedJSValue fill, int32_t delta));	70	JSC_DECLARE_JIT_OPERATION(operationWasmTableGrow, int32_t, (Instance*, unsigned, EncodedJSValue fill, int32_t delta));
69	JSC_DECLARE_JIT_OPERATION(operationWasmTableFill, bool, (Instance*, unsigned, int32_t offset, EncodedJSValue fill, int32_t count));	71	JSC_DECLARE_JIT_OPERATION(operationWasmTableFill, bool, (Instance*, unsigned, int32_t offset, EncodedJSValue fill, int32_t count));
70	JSC_DECLARE_JIT_OPERATION(operationWasmTableCopy, bool, (Instance*, unsigned dstTableIndex, unsigned srcTableIndex, int32_t dstOffset, int32_t srcOffset, int32_t length));	72	JSC_DECLARE_JIT_OPERATION(operationWasmTableCopy, bool, (Instance*, unsigned dstTableIndex, unsigned srcTableIndex, int32_t dstOffset, int32_t srcOffset, int32_t length));



            Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));
            WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");

            WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfIndexes(element.functionIndices, indexCount, elementNum));
                uint32_t funcIndex;
                WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexForElementSection(funcIndex, elementNum, index));
                element.functionIndices.uncheckedAppend(funcIndex);
            }

            m_info->elements.uncheckedAppend(WTFMove(element));
            break;
        }


            uint32_t indexCount;
            WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));
            Element element(Element::Kind::Passive, TableElementType::Funcref);
            WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");

            WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfIndexes(element.functionIndices, indexCount, elementNum));
            m_info->elements.uncheckedAppend(WTFMove(element));
            // Add support for passive element segments and table.init.
            // FIXME: https://bugs.webkit.org/show_bug.cgi?id=219297
            for (uint32_t index = 0; index < indexCount; ++index) {
                uint32_t funcIndex;
                WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexForElementSection(funcIndex, elementNum, index));
            }
            break;
        }
        case 0x02: {

            Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));
            WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");

            WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfIndexes(element.functionIndices, indexCount, elementNum));
                uint32_t funcIndex;
                WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexForElementSection(funcIndex, elementNum, index));
                element.functionIndices.uncheckedAppend(funcIndex);
            }

            m_info->elements.uncheckedAppend(WTFMove(element));
            break;
        }
        case 0x03: {
            WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");

            uint8_t elementKind;
            WASM_FAIL_IF_HELPER_FAILS(parseElementKind(elementKind));

            uint32_t indexCount;
            WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));
            Element element(Element::Kind::Declared, TableElementType::Funcref);
            WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");

            WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfIndexes(element.functionIndices, indexCount, elementNum));
            m_info->elements.uncheckedAppend(WTFMove(element));
            break;
        }
        case 0x04: {

            Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));
            WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");

            WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfExpressions(element.functionIndices, indexCount, elementNum));
                uint32_t funcIndex;
                WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexFromRefExpForElementSection(funcIndex, elementNum, index));
                element.functionIndices.uncheckedAppend(funcIndex);
            }

            m_info->elements.uncheckedAppend(WTFMove(element));
            break;
        }

            WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");
            Type refType;
            WASM_PARSER_FAIL_IF(!parseRefType(refType), "can't parse reftype in elem section");
            WASM_PARSER_FAIL_IF(refType != Funcref, "reftype in element section should be funcref");

            uint32_t indexCount;
            WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));

            Element element(Element::Kind::Passive, TableElementType::Funcref);
            WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
            // Add support for passive element segments and table.init.
            // FIXME: https://bugs.webkit.org/show_bug.cgi?id=219297
            for (unsigned index = 0; index < indexCount; ++index) {
                uint32_t funcIndex;
                WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexFromRefExpForElementSection(funcIndex, elementNum, index));
            }

            WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfExpressions(element.functionIndices, indexCount, elementNum));
            m_info->elements.uncheckedAppend(WTFMove(element));
            break;
        }
        case 0x06: {

            Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));
            WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");

            WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfExpressions(element.functionIndices, indexCount, elementNum));
                uint32_t funcIndex;
                WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexFromRefExpForElementSection(funcIndex, elementNum, index));
                element.functionIndices.uncheckedAppend(funcIndex);
            }

            m_info->elements.uncheckedAppend(WTFMove(element));
            break;
        }
        case 0x07: {
            WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");

            Type refType;
            WASM_PARSER_FAIL_IF(!parseRefType(refType), "can't parse reftype in elem section");
            WASM_PARSER_FAIL_IF(refType != Funcref, "reftype in element section should be funcref");

            uint32_t indexCount;
            WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));

            Element element(Element::Kind::Declared, TableElementType::Funcref);
            WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");

            WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfExpressions(element.functionIndices, indexCount, elementNum));
            m_info->elements.uncheckedAppend(WTFMove(element));
            break;
        }
        default:

    return { };
}

auto SectionParser::parseElementSegmentVectorOfExpressions(Vector<uint32_t>& result, const unsigned indexCount, const unsigned elementNum) -> PartialResult
{
    for (uint32_t index = 0; index < indexCount; ++index) {
        uint8_t opcode;
        WASM_PARSER_FAIL_IF(!parseUInt8(opcode), "can't get opcode for exp in element section's ", elementNum, "th element's ", index, "th index");
        WASM_PARSER_FAIL_IF((opcode != RefFunc) && (opcode != RefNull), "opcode for exp in element section's should be either ref.func or ref.null ", elementNum, "th element's ", index, "th index");

        uint32_t functionIndex;
        if (opcode == RefFunc) {
            WASM_PARSER_FAIL_IF(!parseVarUInt32(functionIndex), "can't get Element section's ", elementNum, "th element's ", index, "th index");
            WASM_PARSER_FAIL_IF(functionIndex >= m_info->functionIndexSpaceSize(), "Element section's ", elementNum, "th element's ", index, "th index is ", functionIndex, " which exceeds the function index space size of ", m_info->functionIndexSpaceSize());
        } else {
            Type typeOfNull;
            WASM_PARSER_FAIL_IF(!parseRefType(typeOfNull), "ref.null type must be a func type in elem section");
            WASM_PARSER_FAIL_IF(typeOfNull != Funcref, "ref.null extern is forbidden in element section's, ", elementNum, "th element's ", index, "th index");
            functionIndex = Element::nullFuncIndex;
        }

        WASM_PARSER_FAIL_IF(!parseUInt8(opcode), "can't get opcode for exp end in element section's ", elementNum, "th element's ", index, "th index");
        WASM_PARSER_FAIL_IF(opcode != End, "malformed expr in element section's", elementNum, "th element's ", index, "th index");

        result.uncheckedAppend(functionIndex);
    }

    return { };
}

auto SectionParser::parseElementSegmentVectorOfIndexes(Vector<uint32_t>& result, const unsigned indexCount, const unsigned elementNum) -> PartialResult
{
    for (uint32_t index = 0; index < indexCount; ++index) {
        uint32_t functionIndex;
        WASM_PARSER_FAIL_IF(!parseVarUInt32(functionIndex), "can't get Element section's ", elementNum, "th element's ", index, "th index");
        WASM_PARSER_FAIL_IF(functionIndex >= m_info->functionIndexSpaceSize(), "Element section's ", elementNum, "th element's ", index, "th index is ", functionIndex, " which exceeds the function index space size of ", m_info->functionIndexSpaceSize());

        result.uncheckedAppend(functionIndex);
    }

    return { };
}



    PartialResult WARN_UNUSED_RETURN parseI32InitExpr(Optional<I32InitExpr>&);
    PartialResult WARN_UNUSED_RETURN parseElementKind(uint8_t& elementKind);
    PartialResult WARN_UNUSED_RETURN parseIndexCountForElementSection(uint32_t&, const unsigned);
    PartialResult WARN_UNUSED_RETURN parseElementSegmentVectorOfExpressions(Vector<uint32_t>&, const unsigned, const unsigned);
    PartialResult WARN_UNUSED_RETURN parseElementSegmentVectorOfIndexes(Vector<uint32_t>&, const unsigned, const unsigned);

    size_t m_offsetInSource;
    Ref<ModuleInformation> m_info;



    WASM_END();
}

WASM_SLOW_PATH_DECL(table_init)
{
    auto instruction = pc->as<WasmTableInit, WasmOpcodeTraits>();
    int32_t dstOffset = READ(instruction.m_dstOffset).unboxedInt32();
    int32_t srcOffset = READ(instruction.m_srcOffset).unboxedInt32();
    int32_t length = READ(instruction.m_length).unboxedInt32();
    if (!Wasm::operationWasmTableInit(instance, instruction.m_elementIndex, instruction.m_tableIndex, dstOffset, srcOffset, length))
        WASM_THROW(Wasm::ExceptionType::OutOfBoundsTableAccess);
    WASM_END();
}

WASM_SLOW_PATH_DECL(elem_drop)
{
    UNUSED_PARAM(callFrame);

    auto instruction = pc->as<WasmElemDrop, WasmOpcodeTraits>();
    Wasm::operationWasmElemDrop(instance, instruction.m_elementIndex);
    WASM_END();
}

WASM_SLOW_PATH_DECL(table_size)
{
    auto instruction = pc->as<WasmTableSize, WasmOpcodeTraits>();

Lines 59-64 WASM_SLOW_PATH_HIDDEN_DECL(out_of_line_jump_target); a/Source/JavaScriptCore/wasm/WasmSlowPaths.h_sec1
- a/Source/JavaScriptCore/wasm/WasmSlowPaths.h +2 lines
59	WASM_SLOW_PATH_HIDDEN_DECL(ref_func);	59	WASM_SLOW_PATH_HIDDEN_DECL(ref_func);
60	WASM_SLOW_PATH_HIDDEN_DECL(table_get);	60	WASM_SLOW_PATH_HIDDEN_DECL(table_get);
61	WASM_SLOW_PATH_HIDDEN_DECL(table_set);	61	WASM_SLOW_PATH_HIDDEN_DECL(table_set);
		62	WASM_SLOW_PATH_HIDDEN_DECL(table_init);
		63	WASM_SLOW_PATH_HIDDEN_DECL(elem_drop);
62	WASM_SLOW_PATH_HIDDEN_DECL(table_size);	64	WASM_SLOW_PATH_HIDDEN_DECL(table_size);
63	WASM_SLOW_PATH_HIDDEN_DECL(table_fill);	65	WASM_SLOW_PATH_HIDDEN_DECL(table_fill);
64	WASM_SLOW_PATH_HIDDEN_DECL(table_copy);	66	WASM_SLOW_PATH_HIDDEN_DECL(table_copy);



    
    Optional<JSValue> exception;

    auto forEachActiveElement = [&] (auto fn) {
        for (const Wasm::Element& element : moduleInformation.elements) {
            if (!element.isActive())
                continue;

            // It should be a validation error to have any elements without a table.
            // Also, it could be that a table wasn't imported, or that the table
            // imported wasn't compatible. However, those should error out before
            // getting here.
            ASSERT(!!m_instance->table(*element.tableIndexIfActive));

            if (!element.functionIndices.size())
                continue;

            if (!element.isActive())
                continue;

            const auto& offset = *element.offsetIfActive;
            const uint32_t elementIndex = offset.isGlobalImport()
                ? static_cast<uint32_t>(m_instance->instance().loadI32Global(offset.globalImportIndex()))
                : offset.constValue();

            fn(element, *element.tableIndexIfActive, elementIndex);

            if (exception)
                break;

    };

    // Validation of all element ranges comes before all Table and Memory initialization.
    forEachActiveElement([&] (const Wasm::Element& element, uint32_t tableIndex, uint32_t elementIndex) {
        int64_t lastWrittenIndex = static_cast<int64_t>(elementIndex) + static_cast<int64_t>(element.functionIndices.size()) - 1;
        if (UNLIKELY(lastWrittenIndex >= m_instance->table(tableIndex)->length()))
            exception = JSValue(throwException(globalObject, scope, createJSWebAssemblyLinkError(globalObject, vm, "Element is trying to set an out of bounds table index"_s)));
    });

    if (UNLIKELY(exception))
        return exception.value();

    forEachActiveElement([&] (const Wasm::Element& element, uint32_t tableIndex, uint32_t startElementIndex) {
        for (uint32_t i = 0; i < element.functionIndices.size(); ++i) {

            const uint32_t elementIndex = startElementIndex + i;
            const uint32_t functionIndex = element.functionIndices[i];
            if (Wasm::Element::isNullFuncIndex(functionIndex)) {

Lines 69-78 a/Source/JavaScriptCore/wasm/wasm.json_sec1
- a/Source/JavaScriptCore/wasm/wasm.json -2 / +4 lines
69	"set_global": { "category": "special", "value": 36, "return": [], "parameter": ["any"], "immediate": [{"name": "global_index", "type": "varuint32"}], "description": "write a global variable" },	69	"set_global": { "category": "special", "value": 36, "return": [], "parameter": ["any"], "immediate": [{"name": "global_index", "type": "varuint32"}], "description": "write a global variable" },
70	"table.get": { "category": "special", "value": 37, "return": ["externref"], "parameter": ["i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "get a table value" },	70	"table.get": { "category": "special", "value": 37, "return": ["externref"], "parameter": ["i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "get a table value" },
71	"table.set": { "category": "special", "value": 38, "return": [], "parameter": ["i32", "externref"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "set a table value" },	71	"table.set": { "category": "special", "value": 38, "return": [], "parameter": ["i32", "externref"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "set a table value" },
		72	"table.init": { "category": "exttable", "value": 252, "return": [], "parameter": ["i32", "i32", "i32"], "immediate": [{"name": "element_index", "type": "varuint32"}, {"name": "table_index","type": "varuint32"}],"description": "initialize table from a given element", "extendedOp": 12 },
		73	"elem.drop": { "category": "exttable", "value": 252, "return": [], "parameter": [], "immediate": [{"name": "element_index", "type": "varuint32"}], "description": "prevents further use of a passive element segment", "extendedOp": 13 },
72	"table.grow": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": ["externref", "i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "grow a table by the given delta and return the previous size, or -1 if enough space cannot be allocated", "extendedOp": 15 },	74	"table.grow": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": ["externref", "i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "grow a table by the given delta and return the previous size, or -1 if enough space cannot be allocated", "extendedOp": 15 },
73	"table.size": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": [], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "get the size of a table", "extendedOp": 16 },	75	"table.size": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": [], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "get the size of a table", "extendedOp": 16 },
74	"table.fill": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": ["i32", "externref", "i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "fill entries [i,i+n) with the given value", "extendedOp": 17 },	76	"table.fill": { "category": "exttable", "value": 252, "return": [], "parameter": ["i32", "externref", "i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "fill entries [i,i+n) with the given value", "extendedOp": 17 },
75	"table.copy": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": ["i32", "i32", "i32"], "immediate": [{"name": "dst_index", "type": "varuint32"}, {"name": "src_index", "type": "varuint32"}],"description": "copy table elements from dst_table[dstOffset, dstOffset + length] to src_table[srcOffset, srcOffset + length]", "extendedOp": 14 },	77	"table.copy": { "category": "exttable", "value": 252, "return": [], "parameter": ["i32", "i32", "i32"], "immediate": [{"name": "dst_index", "type": "varuint32"}, {"name": "src_index", "type": "varuint32"}],"description": "copy table elements from dst_table[dstOffset, dstOffset + length] to src_table[srcOffset, srcOffset + length]", "extendedOp": 14 },
76	"call": { "category": "call", "value": 16, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "function_index", "type": "varuint32"}], "description": "call a function by its index" },	78	"call": { "category": "call", "value": 16, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "function_index", "type": "varuint32"}], "description": "call a function by its index" },
77	"call_indirect": { "category": "call", "value": 17, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "type_index", "type": "varuint32"}, {"name": "table_index","type": "varuint32"}],"description": "call a function indirect with an expected signature" },	79	"call_indirect": { "category": "call", "value": 17, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "type_index", "type": "varuint32"}, {"name": "table_index","type": "varuint32"}],"description": "call a function indirect with an expected signature" },
78	"i32.load8_s": { "category": "memory", "value": 44, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },	80	"i32.load8_s": { "category": "memory", "value": 44, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },



2020-12-08  Dmitry Bezhetskov  <dbezhetskov@igalia.com>

        [WASM-References] Add table.init
        https://bugs.webkit.org/show_bug.cgi?id=219297

        Reviewed by NOBODY (OOPS!).

        Support ref-types spec tests.

        * Scripts/run-jsc-stress-tests:

2020-12-07  Fujii Hironori  <Hironori.Fujii@sony.com>

        Unreviewed sort-Xcode-project-file



    end
end

def runWebAssemblyReferenceSpecTest(mode)
    case mode
    when :skip
        return
    end
    return if !$jitTests
    return if !$isFTLPlatform
    prepareExtraAbsoluteFiles(WASMTESTS_PATH, ["wasm.json"])

    modules = Dir[WASMTESTS_PATH + "*.js"].map { |f| File.basename(f) }
    prepareExtraRelativeFiles(modules.map { |f| "../../" + f }, $collection)

    harness = Dir[WASMTESTS_PATH + "spec-harness/" + "*.js"].map { |f| File.basename(f) }
    prepareExtraRelativeFiles(harness.map { |f| "../../spec-harness/" + f }, $collection)

    runWithOutputHandler("default-wasm", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", *FTL_OPTIONS)
    if $mode != "quick"
      runWithOutputHandler("wasm-no-cjit-yes-tls-context", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--useFastTLSForWasmContext=true", *(FTL_OPTIONS + NO_CJIT_OPTIONS))
      runWithOutputHandler("wasm-eager-jettison", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--forceCodeBlockToJettisonDueToOldAge=true", "--useRandomizingExecutableIslandAllocation=true", *FTL_OPTIONS)
      runWithOutputHandler("wasm-no-tls-context", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--useFastTLSForWasmContext=false", *FTL_OPTIONS)
      runWithOutputHandler("wasm-b3", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--useWasmLLInt=false", "--wasmBBQUsesAir=false", *FTL_OPTIONS)
      runWithOutputHandler("wasm-air", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--useWasmLLInt=false", "--useRandomizingExecutableIslandAllocation=true", *FTL_OPTIONS)
      runWithOutputHandler("wasm-collect-continuously", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--collectContinuously=true", *FTL_OPTIONS) if shouldCollectContinuously?
    end
end

def runWebAssemblyLowExecutableMemory(*optionalTestSpecificOptions)
    return if !$jitTests
    return if !$isFTLPlatform



2020-12-08  Dmitry Bezhetskov  <dbezhetskov@igalia.com>

        [WASM-References] Add table.init
        https://bugs.webkit.org/show_bug.cgi?id=219297

        Reviewed by NOBODY (OOPS!).

        Added reference types spec tests for element section, table.init
        and elem.drop:
        https://github.com/WebAssembly/reference-types/blob/master/test/core/elem.wast,
        https://github.com/WebAssembly/reference-types/blob/master/test/core/table_init.wast.
        Added tests for checking table instructions immediates when they are unreachable.

        * wasm.yaml:
        * wasm/references-spec-tests/elem.wast.js: Added.
        * wasm/references-spec-tests/ref_is_null.js: Removed.
        * wasm/references-spec-tests/ref_is_null.wast.js: Added.
        * wasm/references-spec-tests/ref_null.js: Removed.
        * wasm/references-spec-tests/ref_null.wast.js: Added.
        * wasm/references-spec-tests/table_copy.wast.js: Renamed from JSTests/wasm/references-spec-tests/table_copy.js.
        * wasm/references-spec-tests/table_init.wast.js: Added.
        * wasm/spec-harness/wasm-constants.js:
        (hostref):
        * wasm/wasm.json:

2020-12-07  Dmitry Bezhetskov  <dbezhetskov@igalia.com>

        [WASM-References] Add support for table.copy



  cmd: runWebAssemblySuite unless parseRunCommands
- path: wasm/references
  cmd: runWebAssemblySuite unless parseRunCommands
- path: wasm/references-spec-tests
  cmd: runWebAssemblySuite unless parseRunCommands
- path: wasm/fuzz
  cmd: runWebAssemblySuite unless parseRunCommands
- path: wasm/lowExecutableMemory

- path: wasm/self-test/
  cmd: runWebAssemblySuite unless parseRunCommands

- path: wasm/references-spec-tests/elem.wast.js
  cmd: runWebAssemblyReferenceSpecTest :normal
- path: wasm/references-spec-tests/ref_null.wast.js
  cmd: runWebAssemblyReferenceSpecTest :normal
- path: wasm/references-spec-tests/ref_is_null.wast.js
  cmd: runWebAssemblyReferenceSpecTest :normal
- path: wasm/references-spec-tests/table_copy.wast.js
  cmd: runWebAssemblyReferenceSpecTest :normal
- path: wasm/references-spec-tests/table_init.wast.js
  cmd: runWebAssemblyReferenceSpecTest :normal

- path: wasm/multi-value-spec-tests/block.wast.js
  cmd: runWebAssemblySpecTest :normal
- path: wasm/multi-value-spec-tests/br.wast.js




// elem.wast:4
let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x99\x83\x80\x80\x00\x3c\x01\x00\x00\x05\x70\x04\xd2\x00\x0b\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x01\x00\x00\x01\x00\x04\x00\x00\x01\x01\x01\x00\x00\x05\x70\x04\xd2\x00\x0b\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x01\x00\x00\x01\x00\x04\x00\x00\x01\x01\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x01\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x01\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x01\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x01\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x02\x00\x00\x03\x00\x00\x07\x70\x04\xd2\x00\x0b\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x03\x00\x00\x03\x00\x04\x00\x00\x01\x01\x03\x00\x00\x07\x70\x04\xd2\x00\x0b\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x03\x00\x00\x03\x00\x04\x00\x00\x01\x01\x0a\x8f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:79
let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x85\x80\x80\x80\x00\x01\x70\x01\x03\x03\x09\x8f\x80\x80\x80\x00\x01\x04\x41\x00\x0b\x03\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x0a\x8f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:89
let $3 = instance("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:94
let $4 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:100
let $5 = instance("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x9f\x80\x80\x80\x00\x05\x00\x41\x00\x0b\x01\x00\x00\x41\x03\x0b\x01\x00\x00\x41\x07\x0b\x01\x00\x00\x41\x05\x0b\x01\x00\x00\x41\x03\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:109
let $6 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x9f\x80\x80\x80\x00\x05\x00\x41\x09\x0b\x01\x00\x00\x41\x03\x0b\x01\x00\x00\x41\x07\x0b\x01\x00\x00\x41\x03\x0b\x01\x00\x00\x41\x05\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:119
let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x98\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x0a\x67\x6c\x6f\x62\x61\x6c\x5f\x69\x33\x32\x03\x7f\x00\x03\x82\x80\x80\x80\x00\x01\x00\x04\x85\x80\x80\x80\x00\x01\x70\x00\xe8\x07\x09\x87\x80\x80\x80\x00\x01\x00\x23\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:126
let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x98\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x0a\x67\x6c\x6f\x62\x61\x6c\x5f\x69\x33\x32\x03\x7f\x00\x03\x82\x80\x80\x80\x00\x01\x00\x04\x85\x80\x80\x80\x00\x01\x70\x00\xe8\x07\x09\x87\x80\x80\x80\x00\x01\x00\x23\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:133
let $9 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x85\x80\x80\x80\x00\x04\x00\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x93\x80\x80\x80\x00\x02\x06\x63\x61\x6c\x6c\x2d\x37\x00\x02\x06\x63\x61\x6c\x6c\x2d\x39\x00\x03\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x07\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\xad\x80\x80\x80\x00\x04\x85\x80\x80\x80\x00\x00\x41\xc1\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc2\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x07\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x09\x11\x00\x00\x0b");

// elem.wast:147
assert_return(() => call($9, "call-7", []), 65);

// elem.wast:148
assert_return(() => call($9, "call-9", []), 66);

// elem.wast:152
let $10 = instance("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x09\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:157
let $11 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x09\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:163
let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x00\x09\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");

// elem.wast:167
let $13 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x00\x09\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");

// elem.wast:172
let $14 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x85\x80\x80\x80\x00\x01\x70\x01\x00\x00\x09\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");

// elem.wast:177
let $15 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x14\x09\x86\x80\x80\x80\x00\x01\x00\x41\x14\x0b\x00");

// elem.wast:182
let $16 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:188
let $17 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x95\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x01\x00\x64\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:194
let $18 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:200
let $19 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x95\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x01\x00\x1e\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:208
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:217
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\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\x04\x85\x80\x80\x80\x00\x01\x70\x01\x00\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:226
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\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\x04\x85\x80\x80\x80\x00\x01\x70\x01\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:235
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x00\x09\x86\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x00");

// elem.wast:242
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x0a\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:250
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x0a\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:259
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\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\x04\x85\x80\x80\x80\x00\x01\x70\x01\x0a\x14\x09\x87\x80\x80\x80\x00\x01\x00\x41\x0a\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:267
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x0a\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:276
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x7f\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:284
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x7f\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:293
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x76\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:301
// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x76\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:312
let $20 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x69\x6e\x69\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x01\xfc\x0c\x00\x00\x0b");

// elem.wast:320
assert_trap(() => call($20, "init", []));

// elem.wast:322
let $21 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x69\x6e\x69\x74\x00\x01\x09\x85\x80\x80\x80\x00\x01\x03\x00\x01\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x01\xfc\x0c\x00\x00\x0b");

// elem.wast:330
assert_trap(() => call($21, "init", []));

// elem.wast:334
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\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");

// elem.wast:344
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x86\x80\x80\x80\x00\x01\x00\x42\x00\x0b\x00");

// elem.wast:352
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x68\x0b\x00");

// elem.wast:360
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x85\x80\x80\x80\x00\x01\x00\x01\x0b\x00");

// elem.wast:368
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x01\x41\x00\x0b\x00");

// elem.wast:376
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x01\x0b\x00");

// elem.wast:392
let $22 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x84\x80\x80\x80\x00\x03\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x94\x80\x80\x80\x00\x01\x10\x63\x61\x6c\x6c\x2d\x6f\x76\x65\x72\x77\x72\x69\x74\x74\x65\x6e\x00\x02\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x09\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\xa1\x80\x80\x80\x00\x03\x85\x80\x80\x80\x00\x00\x41\xc1\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc2\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x09\x11\x00\x00\x0b");

// elem.wast:403
assert_return(() => call($22, "call-overwritten", []), 66);

// elem.wast:405
let $23 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x84\x80\x80\x80\x00\x03\x00\x00\x00\x07\x9c\x80\x80\x80\x00\x01\x18\x63\x61\x6c\x6c\x2d\x6f\x76\x65\x72\x77\x72\x69\x74\x74\x65\x6e\x2d\x65\x6c\x65\x6d\x65\x6e\x74\x00\x02\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x09\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\xa1\x80\x80\x80\x00\x03\x85\x80\x80\x80\x00\x00\x41\xc1\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc2\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x09\x11\x00\x00\x0b");

// elem.wast:416
assert_return(() => call($23, "call-overwritten-element", []), 66);

// elem.wast:420
let $24 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x86\x80\x80\x80\x00\x05\x00\x00\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\xab\x80\x80\x80\x00\x04\x0c\x73\x68\x61\x72\x65\x64\x2d\x74\x61\x62\x6c\x65\x01\x00\x06\x63\x61\x6c\x6c\x2d\x37\x00\x02\x06\x63\x61\x6c\x6c\x2d\x38\x00\x03\x06\x63\x61\x6c\x6c\x2d\x39\x00\x04\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x08\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\xb9\x80\x80\x80\x00\x05\x85\x80\x80\x80\x00\x00\x41\xc1\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc2\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x07\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x08\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x09\x11\x00\x00\x0b");
let $module1 = $24;

// elem.wast:438
register("module1", $module1)

// elem.wast:440
assert_trap(() => call($module1, "call-7", []));

// elem.wast:441
assert_return(() => call($module1, "call-8", []), 65);

// elem.wast:442
assert_return(() => call($module1, "call-9", []), 66);

// elem.wast:444
let $25 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x02\x9a\x80\x80\x80\x00\x01\x07\x6d\x6f\x64\x75\x6c\x65\x31\x0c\x73\x68\x61\x72\x65\x64\x2d\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x83\x80\x80\x80\x00\x02\x00\x00\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x07\x0b\x01\x00\x00\x41\x08\x0b\x01\x01\x0a\x95\x80\x80\x80\x00\x02\x85\x80\x80\x80\x00\x00\x41\xc3\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc4\x00\x0b");
let $module2 = $25;

// elem.wast:453
assert_return(() => call($module1, "call-7", []), 67);

// elem.wast:454
assert_return(() => call($module1, "call-8", []), 68);

// elem.wast:455
assert_return(() => call($module1, "call-9", []), 66);

// elem.wast:457
let $26 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x02\x9a\x80\x80\x80\x00\x01\x07\x6d\x6f\x64\x75\x6c\x65\x31\x0c\x73\x68\x61\x72\x65\x64\x2d\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x83\x80\x80\x80\x00\x02\x00\x00\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x08\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\x95\x80\x80\x80\x00\x02\x85\x80\x80\x80\x00\x00\x41\xc5\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc6\x00\x0b");
let $module3 = $26;

// elem.wast:466
assert_return(() => call($module1, "call-7", []), 67);

// elem.wast:467
assert_return(() => call($module1, "call-8", []), 69);

// elem.wast:468
assert_return(() => call($module1, "call-9", []), 70);



//@ runWebAssemblySuite("--useWebAssemblyReferences=true")
'use strict';
let console = { log: print }
let hostrefs = {};
let hostsym = Symbol("hostref");
function hostref(s) {
  if (! (s in hostrefs)) hostrefs[s] = {[hostsym]: s};
  return hostrefs[s];
}
function is_hostref(x) {
  return (x !== null && hostsym in x) ? 1 : 0;
}
function is_funcref(x) {
  return typeof x === "function" ? 1 : 0;
}
function eq_ref(x, y) {
  return x === y ? 1 : 0;
}

let spectest = {
  hostref: hostref,
  is_hostref: is_hostref,
  is_funcref: is_funcref,
  eq_ref: eq_ref,
  print: console.log.bind(console),
  print_i32: console.log.bind(console),
  print_i32_f32: console.log.bind(console),
  print_f64_f64: console.log.bind(console),
  print_f32: console.log.bind(console),
  print_f64: console.log.bind(console),
  global_i32: 666,
  global_f32: 666,
  global_f64: 666,
  table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),
  memory: new WebAssembly.Memory({initial: 1, maximum: 2})
};

let handler = {
  get(target, prop) {
    return (prop in target) ?  target[prop] : {};
  }
};
let registry = new Proxy({spectest}, handler);

function register(name, instance) {
  registry[name] = instance.exports;
}

function module(bytes, valid = true) {
  let buffer = new ArrayBuffer(bytes.length);
  let view = new Uint8Array(buffer);
  for (let i = 0; i < bytes.length; ++i) {
    view[i] = bytes.charCodeAt(i);
  }
  let validated;
  try {
    validated = WebAssembly.validate(buffer);
  } catch (e) {
    throw new Error("Wasm validate throws");
  }
  if (validated !== valid) {
    throw new Error("Wasm validate failure" + (valid ? "" : " expected"));
  }
  return new WebAssembly.Module(buffer);
}

function instance(bytes, imports = registry) {
  return new WebAssembly.Instance(module(bytes), imports);
}

function call(instance, name, args) {
  return instance.exports[name](...args);
}

function get(instance, name) {
  let v = instance.exports[name];
  return (v instanceof WebAssembly.Global) ? v.value : v;
}

function exports(instance) {
  return {module: instance.exports, spectest: spectest};
}

function run(action) {
  action();
}

function assert_malformed(bytes) {
  try { module(bytes, false) } catch (e) {
    if (e instanceof WebAssembly.CompileError) return;
  }
  throw new Error("Wasm decoding failure expected");
}

function assert_invalid(bytes) {
  try { module(bytes, false) } catch (e) {
    if (e instanceof WebAssembly.CompileError) return;
  }
  throw new Error("Wasm validation failure expected");
}

function assert_unlinkable(bytes) {
  let mod = module(bytes);
  try { new WebAssembly.Instance(mod, registry) } catch (e) {
    if (e instanceof WebAssembly.LinkError) return;
  }
  throw new Error("Wasm linking failure expected");
}

function assert_uninstantiable(bytes) {
  let mod = module(bytes);
  try { new WebAssembly.Instance(mod, registry) } catch (e) {
    if (e instanceof WebAssembly.RuntimeError) return;
  }
  throw new Error("Wasm trap expected");
}

function assert_trap(action) {
  try { action() } catch (e) {
    if (e instanceof WebAssembly.RuntimeError) return;
  }
  throw new Error("Wasm trap expected");
}

let StackOverflow;
try { (function f() { 1 + f() })() } catch (e) { StackOverflow = e.constructor }

function assert_exhaustion(action) {
  try { action() } catch (e) {
    if (e instanceof StackOverflow) return;
  }
  throw new Error("Wasm resource exhaustion expected");
}

function assert_return(action, expected) {
  let actual = action();
  if (!Object.is(actual, expected)) {
    throw new Error("Wasm return value " + expected + " expected, got " + actual);
  };
}

function assert_return_canonical_nan(action) {
  let actual = action();
  // Note that JS can't reliably distinguish different NaN values,
  // so there's no good way to test that it's a canonical NaN.
  if (!Number.isNaN(actual)) {
    throw new Error("Wasm return value NaN expected, got " + actual);
  };
}

function assert_return_arithmetic_nan(action) {
  // Note that JS can't reliably distinguish different NaN values,
  // so there's no good way to test for specific bitpatterns here.
  let actual = action();
  if (!Number.isNaN(actual)) {
    throw new Error("Wasm return value NaN expected, got " + actual);
  };
}

function assert_return_ref(action) {
  let actual = action();
  if (actual === null || typeof actual !== "object" && typeof actual !== "function") {
    throw new Error("Wasm reference return value expected, got " + actual);
  };
}

function assert_return_func(action) {
  let actual = action();
  if (typeof actual !== "function") {
    throw new Error("Wasm function return value expected, got " + actual);
  };
}

// ref_is_null.wast:1
let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x97\x80\x80\x80\x00\x05\x60\x01\x70\x01\x7f\x60\x01\x6f\x01\x7f\x60\x00\x00\x60\x01\x6f\x00\x60\x01\x7f\x01\x7f\x03\x88\x80\x80\x80\x00\x07\x00\x01\x02\x03\x02\x04\x04\x04\x87\x80\x80\x80\x00\x02\x70\x00\x02\x6f\x00\x02\x07\xc7\x80\x80\x80\x00\x06\x07\x66\x75\x6e\x63\x72\x65\x66\x00\x00\x09\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x00\x01\x04\x69\x6e\x69\x74\x00\x03\x06\x64\x65\x69\x6e\x69\x74\x00\x04\x0c\x66\x75\x6e\x63\x72\x65\x66\x2d\x65\x6c\x65\x6d\x00\x05\x0e\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x2d\x65\x6c\x65\x6d\x00\x06\x09\x87\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x01\x02\x0a\xd6\x80\x80\x80\x00\x07\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b\x82\x80\x80\x80\x00\x00\x0b\x88\x80\x80\x80\x00\x00\x41\x01\x20\x00\x26\x01\x0b\x8e\x80\x80\x80\x00\x00\x41\x01\xd0\x70\x26\x00\x41\x01\xd0\x6f\x26\x01\x0b\x88\x80\x80\x80\x00\x00\x20\x00\x25\x00\x10\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\x25\x01\x10\x01\x0b");

// ref_is_null.wast:30
assert_return(() => call($1, "funcref", [null]), 1);

// ref_is_null.wast:31
assert_return(() => call($1, "externref", [null]), 1);

// ref_is_null.wast:33
assert_return(() => call($1, "externref", [hostref(1)]), 0);

// ref_is_null.wast:35
run(() => call($1, "init", [hostref(0)]));

// ref_is_null.wast:37
assert_return(() => call($1, "funcref-elem", [0]), 1);

// ref_is_null.wast:38
assert_return(() => call($1, "externref-elem", [0]), 1);

// ref_is_null.wast:40
assert_return(() => call($1, "funcref-elem", [1]), 0);

// ref_is_null.wast:41
assert_return(() => call($1, "externref-elem", [1]), 0);

// ref_is_null.wast:43
run(() => call($1, "deinit", []));

// ref_is_null.wast:45
assert_return(() => call($1, "funcref-elem", [0]), 1);

// ref_is_null.wast:46
assert_return(() => call($1, "externref-elem", [0]), 1);

// ref_is_null.wast:48
assert_return(() => call($1, "funcref-elem", [1]), 1);

// ref_is_null.wast:49
assert_return(() => call($1, "externref-elem", [1]), 1);

// ref_is_null.wast:51
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x01\x7f\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8b\x80\x80\x80\x00\x01\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b");

// ref_is_null.wast:55
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\x89\x80\x80\x80\x00\x01\x83\x80\x80\x80\x00\x00\xd1\x0b");




// ref_is_null.wast:1
let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x97\x80\x80\x80\x00\x05\x60\x01\x70\x01\x7f\x60\x01\x6f\x01\x7f\x60\x00\x00\x60\x01\x6f\x00\x60\x01\x7f\x01\x7f\x03\x88\x80\x80\x80\x00\x07\x00\x01\x02\x03\x02\x04\x04\x04\x87\x80\x80\x80\x00\x02\x70\x00\x02\x6f\x00\x02\x07\xc7\x80\x80\x80\x00\x06\x07\x66\x75\x6e\x63\x72\x65\x66\x00\x00\x09\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x00\x01\x04\x69\x6e\x69\x74\x00\x03\x06\x64\x65\x69\x6e\x69\x74\x00\x04\x0c\x66\x75\x6e\x63\x72\x65\x66\x2d\x65\x6c\x65\x6d\x00\x05\x0e\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x2d\x65\x6c\x65\x6d\x00\x06\x09\x87\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x01\x02\x0a\xd6\x80\x80\x80\x00\x07\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b\x82\x80\x80\x80\x00\x00\x0b\x88\x80\x80\x80\x00\x00\x41\x01\x20\x00\x26\x01\x0b\x8e\x80\x80\x80\x00\x00\x41\x01\xd0\x70\x26\x00\x41\x01\xd0\x6f\x26\x01\x0b\x88\x80\x80\x80\x00\x00\x20\x00\x25\x00\x10\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\x25\x01\x10\x01\x0b");

// ref_is_null.wast:30
assert_return(() => call($1, "funcref", [null]), 1);

// ref_is_null.wast:31
assert_return(() => call($1, "externref", [null]), 1);

// ref_is_null.wast:33
assert_return(() => call($1, "externref", [hostref(1)]), 0);

// ref_is_null.wast:35
run(() => call($1, "init", [hostref(0)]));

// ref_is_null.wast:37
assert_return(() => call($1, "funcref-elem", [0]), 1);

// ref_is_null.wast:38
assert_return(() => call($1, "externref-elem", [0]), 1);

// ref_is_null.wast:40
assert_return(() => call($1, "funcref-elem", [1]), 0);

// ref_is_null.wast:41
assert_return(() => call($1, "externref-elem", [1]), 0);

// ref_is_null.wast:43
run(() => call($1, "deinit", []));

// ref_is_null.wast:45
assert_return(() => call($1, "funcref-elem", [0]), 1);

// ref_is_null.wast:46
assert_return(() => call($1, "externref-elem", [0]), 1);

// ref_is_null.wast:48
assert_return(() => call($1, "funcref-elem", [1]), 1);

// ref_is_null.wast:49
assert_return(() => call($1, "externref-elem", [1]), 1);

// ref_is_null.wast:51
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x01\x7f\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8b\x80\x80\x80\x00\x01\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b");

// ref_is_null.wast:55
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\x89\x80\x80\x80\x00\x01\x83\x80\x80\x80\x00\x00\xd1\x0b");



//@ runWebAssemblySuite("--useWebAssemblyReferences=true")
'use strict';

let console = { log: print }

let hostrefs = {};
let hostsym = Symbol("hostref");
function hostref(s) {
  if (! (s in hostrefs)) hostrefs[s] = {[hostsym]: s};
  return hostrefs[s];
}
function is_hostref(x) {
  return (x !== null && hostsym in x) ? 1 : 0;
}
function is_funcref(x) {
  return typeof x === "function" ? 1 : 0;
}
function eq_ref(x, y) {
  return x === y ? 1 : 0;
}

let spectest = {
  hostref: hostref,
  is_hostref: is_hostref,
  is_funcref: is_funcref,
  eq_ref: eq_ref,
  print: console.log.bind(console),
  print_i32: console.log.bind(console),
  print_i32_f32: console.log.bind(console),
  print_f64_f64: console.log.bind(console),
  print_f32: console.log.bind(console),
  print_f64: console.log.bind(console),
  global_i32: 666,
  global_f32: 666,
  global_f64: 666,
  table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),
  memory: new WebAssembly.Memory({initial: 1, maximum: 2})
};

let handler = {
  get(target, prop) {
    return (prop in target) ?  target[prop] : {};
  }
};
let registry = new Proxy({spectest}, handler);

function register(name, instance) {
  registry[name] = instance.exports;
}

function module(bytes, valid = true) {
  let buffer = new ArrayBuffer(bytes.length);
  let view = new Uint8Array(buffer);
  for (let i = 0; i < bytes.length; ++i) {
    view[i] = bytes.charCodeAt(i);
  }
  let validated;
  try {
    validated = WebAssembly.validate(buffer);
  } catch (e) {
    console.log(e)
    throw new Error("Wasm validate throws");
  }
  if (validated !== valid) {
    throw new Error("Wasm validate failure" + (valid ? "" : " expected"));
  }
  return new WebAssembly.Module(buffer);
}

function instance(bytes, imports = registry) {
  return new WebAssembly.Instance(module(bytes), imports);
}

function call(instance, name, args) {
  return instance.exports[name](...args);
}

function get(instance, name) {
  let v = instance.exports[name];
  return (v instanceof WebAssembly.Global) ? v.value : v;
}

function exports(instance) {
  return {module: instance.exports, spectest: spectest};
}

function run(action) {
  action();
}

function assert_malformed(bytes) {
  try { module(bytes, false) } catch (e) {
    if (e instanceof WebAssembly.CompileError) return;
  }
  throw new Error("Wasm decoding failure expected");
}

function assert_invalid(bytes) {
  try { module(bytes, false) } catch (e) {
    if (e instanceof WebAssembly.CompileError) return;
  }
  throw new Error("Wasm validation failure expected");
}

function assert_unlinkable(bytes) {
  let mod = module(bytes);
  try { new WebAssembly.Instance(mod, registry) } catch (e) {
    if (e instanceof WebAssembly.LinkError) return;
  }
  throw new Error("Wasm linking failure expected");
}

function assert_uninstantiable(bytes) {
  let mod = module(bytes);
  try { new WebAssembly.Instance(mod, registry) } catch (e) {
    if (e instanceof WebAssembly.RuntimeError) return;
  }
  throw new Error("Wasm trap expected");
}

function assert_trap(action) {
  try { action() } catch (e) {
    if (e instanceof WebAssembly.RuntimeError) return;
  }
  throw new Error("Wasm trap expected");
}

let StackOverflow;
try { (function f() { 1 + f() })() } catch (e) { StackOverflow = e.constructor }

function assert_exhaustion(action) {
  try { action() } catch (e) {
    if (e instanceof StackOverflow) return;
  }
  throw new Error("Wasm resource exhaustion expected");
}

function assert_return(action, expected) {
  let actual = action();
  if (!Object.is(actual, expected)) {
    throw new Error("Wasm return value " + expected + " expected, got " + actual);
  };
}

function assert_return_canonical_nan(action) {
  let actual = action();
  // Note that JS can't reliably distinguish different NaN values,
  // so there's no good way to test that it's a canonical NaN.
  if (!Number.isNaN(actual)) {
    throw new Error("Wasm return value NaN expected, got " + actual);
  };
}

function assert_return_arithmetic_nan(action) {
  // Note that JS can't reliably distinguish different NaN values,
  // so there's no good way to test for specific bitpatterns here.
  let actual = action();
  if (!Number.isNaN(actual)) {
    throw new Error("Wasm return value NaN expected, got " + actual);
  };
}

function assert_return_ref(action) {
  let actual = action();
  if (actual === null || typeof actual !== "object" && typeof actual !== "function") {
    throw new Error("Wasm reference return value expected, got " + actual);
  };
}

function assert_return_func(action) {
  let actual = action();
  if (typeof actual !== "function") {
    throw new Error("Wasm function return value expected, got " + actual);
  };
}

// ref_null.wast:1
let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x01\x6f\x60\x00\x01\x70\x03\x83\x80\x80\x80\x00\x02\x00\x01\x06\x8b\x80\x80\x80\x00\x02\x6f\x00\xd0\x6f\x0b\x70\x00\xd0\x70\x0b\x07\x97\x80\x80\x80\x00\x02\x09\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x00\x00\x07\x66\x75\x6e\x63\x72\x65\x66\x00\x01\x0a\x93\x80\x80\x80\x00\x02\x84\x80\x80\x80\x00\x00\xd0\x6f\x0b\x84\x80\x80\x80\x00\x00\xd0\x70\x0b");

// ref_null.wast:9
assert_return(() => call($1, "externref", []), null);

// ref_null.wast:10
assert_return(() => call($1, "funcref", []), null);




// ref_null.wast:1
let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x01\x6f\x60\x00\x01\x70\x03\x83\x80\x80\x80\x00\x02\x00\x01\x06\x8b\x80\x80\x80\x00\x02\x6f\x00\xd0\x6f\x0b\x70\x00\xd0\x70\x0b\x07\x97\x80\x80\x80\x00\x02\x09\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x00\x00\x07\x66\x75\x6e\x63\x72\x65\x66\x00\x01\x0a\x93\x80\x80\x80\x00\x02\x84\x80\x80\x80\x00\x00\xd0\x6f\x0b\x84\x80\x80\x80\x00\x00\xd0\x70\x0b");

// ref_null.wast:9
assert_return(() => call($1, "externref", []), null);

// ref_null.wast:10
assert_return(() => call($1, "funcref", []), null);



//@ runWebAssemblySuite("--useWebAssemblyReferences=true")
'use strict';

let console = { log: print }

let hostrefs = {};
let hostsym = Symbol("hostref");
function hostref(s) {
  if (! (s in hostrefs)) hostrefs[s] = {[hostsym]: s};
  return hostrefs[s];
}
function is_hostref(x) {
  return (x !== null && hostsym in x) ? 1 : 0;
}
function is_funcref(x) {
  return typeof x === "function" ? 1 : 0;
}
function eq_ref(x, y) {
  return x === y ? 1 : 0;
}

let spectest = {
  hostref: hostref,
  is_hostref: is_hostref,
  is_funcref: is_funcref,
  eq_ref: eq_ref,
  print: console.log.bind(console),
  print_i32: console.log.bind(console),
  print_i32_f32: console.log.bind(console),
  print_f64_f64: console.log.bind(console),
  print_f32: console.log.bind(console),
  print_f64: console.log.bind(console),
  global_i32: 666,
  global_f32: 666,
  global_f64: 666,
  table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),
  memory: new WebAssembly.Memory({initial: 1, maximum: 2})
};

let handler = {
  get(target, prop) {
    return (prop in target) ?  target[prop] : {};
  }
};
let registry = new Proxy({spectest}, handler);

function register(name, instance) {
  registry[name] = instance.exports;
}

function module(bytes, valid = true) {
  let buffer = new ArrayBuffer(bytes.length);
  let view = new Uint8Array(buffer);
  for (let i = 0; i < bytes.length; ++i) {
    view[i] = bytes.charCodeAt(i);
  }
  let validated;
  try {
    validated = WebAssembly.validate(buffer);
  } catch (e) {
    console.log(e)
    throw new Error("Wasm validate throws");
  }
  if (validated !== valid) {
    throw new Error("Wasm validate failure" + (valid ? "" : " expected"));
  }
  return new WebAssembly.Module(buffer);
}

function instance(bytes, imports = registry) {
  return new WebAssembly.Instance(module(bytes), imports);
}

function call(instance, name, args) {
  return instance.exports[name](...args);
}

function get(instance, name) {
  let v = instance.exports[name];
  return (v instanceof WebAssembly.Global) ? v.value : v;
}

function exports(instance) {
  return {module: instance.exports, spectest: spectest};
}

function run(action) {
  action();
}

function assert_malformed(bytes) {
  try { module(bytes, false) } catch (e) {
    if (e instanceof WebAssembly.CompileError) return;
  }
  throw new Error("Wasm decoding failure expected");
}

function assert_invalid(bytes) {
  try { module(bytes, false) } catch (e) {
    if (e instanceof WebAssembly.CompileError) return;
  }
  throw new Error("Wasm validation failure expected");
}

function assert_unlinkable(bytes) {
  let mod = module(bytes);
  try { new WebAssembly.Instance(mod, registry) } catch (e) {
    if (e instanceof WebAssembly.LinkError) return;
  }
  throw new Error("Wasm linking failure expected");
}

function assert_uninstantiable(bytes) {
  let mod = module(bytes);
  try { new WebAssembly.Instance(mod, registry) } catch (e) {
    if (e instanceof WebAssembly.RuntimeError) return;
  }
  throw new Error("Wasm trap expected");
}

function assert_trap(action) {
  try { action() } catch (e) {
    if (e instanceof WebAssembly.RuntimeError) return;
  }
  throw new Error("Wasm trap expected");
}

let StackOverflow;
try { (function f() { 1 + f() })() } catch (e) { StackOverflow = e.constructor }

function assert_exhaustion(action) {
  try { action() } catch (e) {
    if (e instanceof StackOverflow) return;
  }
  throw new Error("Wasm resource exhaustion expected");
}

function assert_return(action, expected) {
  let actual = action();
  if (!Object.is(actual, expected)) {
    throw new Error("Wasm return value " + expected + " expected, got " + actual);
  };
}

function assert_return_canonical_nan(action) {
  let actual = action();
  // Note that JS can't reliably distinguish different NaN values,
  // so there's no good way to test that it's a canonical NaN.
  if (!Number.isNaN(actual)) {
    throw new Error("Wasm return value NaN expected, got " + actual);
  };
}

function assert_return_arithmetic_nan(action) {
  // Note that JS can't reliably distinguish different NaN values,
  // so there's no good way to test for specific bitpatterns here.
  let actual = action();
  if (!Number.isNaN(actual)) {
    throw new Error("Wasm return value NaN expected, got " + actual);
  };
}

function assert_return_ref(action) {
  let actual = action();
  if (actual === null || typeof actual !== "object" && typeof actual !== "function") {
    throw new Error("Wasm reference return value expected, got " + actual);
  };
}

function assert_return_func(action) {
  let actual = action();
  if (typeof actual !== "function") {
    throw new Error("Wasm function return value expected, got " + actual);
  };
}

// table_copy.wast:6
let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x86\x80\x80\x80\x00\x05\x00\x00\x00\x00\x00\x07\x9f\x80\x80\x80\x00\x05\x03\x65\x66\x30\x00\x00\x03\x65\x66\x31\x00\x01\x03\x65\x66\x32\x00\x02\x03\x65\x66\x33\x00\x03\x03\x65\x66\x34\x00\x04\x0a\xae\x80\x80\x80\x00\x05\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b");

// table_copy.wast:13
register("a", $1)

// table_copy.wast:15
let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xce\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x83\x80\x80\x80\x00\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:45
run(() => call($2, "test", []));

// table_copy.wast:46
assert_trap(() => call($2, "check_t0", [0]));

// table_copy.wast:47
assert_trap(() => call($2, "check_t0", [1]));

// table_copy.wast:48
assert_return(() => call($2, "check_t0", [2]), 3);

// table_copy.wast:49
assert_return(() => call($2, "check_t0", [3]), 1);

// table_copy.wast:50
assert_return(() => call($2, "check_t0", [4]), 4);

// table_copy.wast:51
assert_return(() => call($2, "check_t0", [5]), 1);

// table_copy.wast:52
assert_trap(() => call($2, "check_t0", [6]));

// table_copy.wast:53
assert_trap(() => call($2, "check_t0", [7]));

// table_copy.wast:54
assert_trap(() => call($2, "check_t0", [8]));

// table_copy.wast:55
assert_trap(() => call($2, "check_t0", [9]));

// table_copy.wast:56
assert_trap(() => call($2, "check_t0", [10]));

// table_copy.wast:57
assert_trap(() => call($2, "check_t0", [11]));

// table_copy.wast:58
assert_return(() => call($2, "check_t0", [12]), 7);

// table_copy.wast:59
assert_return(() => call($2, "check_t0", [13]), 5);

// table_copy.wast:60
assert_return(() => call($2, "check_t0", [14]), 2);

// table_copy.wast:61
assert_return(() => call($2, "check_t0", [15]), 3);

// table_copy.wast:62
assert_return(() => call($2, "check_t0", [16]), 6);

// table_copy.wast:63
assert_trap(() => call($2, "check_t0", [17]));

// table_copy.wast:64
assert_trap(() => call($2, "check_t0", [18]));

// table_copy.wast:65
assert_trap(() => call($2, "check_t0", [19]));

// table_copy.wast:66
assert_trap(() => call($2, "check_t0", [20]));

// table_copy.wast:67
assert_trap(() => call($2, "check_t0", [21]));

// table_copy.wast:68
assert_trap(() => call($2, "check_t0", [22]));

// table_copy.wast:69
assert_trap(() => call($2, "check_t0", [23]));

// table_copy.wast:70
assert_trap(() => call($2, "check_t0", [24]));

// table_copy.wast:71
assert_trap(() => call($2, "check_t0", [25]));

// table_copy.wast:72
assert_trap(() => call($2, "check_t0", [26]));

// table_copy.wast:73
assert_trap(() => call($2, "check_t0", [27]));

// table_copy.wast:74
assert_trap(() => call($2, "check_t0", [28]));

// table_copy.wast:75
assert_trap(() => call($2, "check_t0", [29]));

// table_copy.wast:76
assert_trap(() => call($2, "check_t1", [0]));

// table_copy.wast:77
assert_trap(() => call($2, "check_t1", [1]));

// table_copy.wast:78
assert_trap(() => call($2, "check_t1", [2]));

// table_copy.wast:79
assert_return(() => call($2, "check_t1", [3]), 1);

// table_copy.wast:80
assert_return(() => call($2, "check_t1", [4]), 3);

// table_copy.wast:81
assert_return(() => call($2, "check_t1", [5]), 1);

// table_copy.wast:82
assert_return(() => call($2, "check_t1", [6]), 4);

// table_copy.wast:83
assert_trap(() => call($2, "check_t1", [7]));

// table_copy.wast:84
assert_trap(() => call($2, "check_t1", [8]));

// table_copy.wast:85
assert_trap(() => call($2, "check_t1", [9]));

// table_copy.wast:86
assert_trap(() => call($2, "check_t1", [10]));

// table_copy.wast:87
assert_return(() => call($2, "check_t1", [11]), 6);

// table_copy.wast:88
assert_return(() => call($2, "check_t1", [12]), 3);

// table_copy.wast:89
assert_return(() => call($2, "check_t1", [13]), 2);

// table_copy.wast:90
assert_return(() => call($2, "check_t1", [14]), 5);

// table_copy.wast:91
assert_return(() => call($2, "check_t1", [15]), 7);

// table_copy.wast:92
assert_trap(() => call($2, "check_t1", [16]));

// table_copy.wast:93
assert_trap(() => call($2, "check_t1", [17]));

// table_copy.wast:94
assert_trap(() => call($2, "check_t1", [18]));

// table_copy.wast:95
assert_trap(() => call($2, "check_t1", [19]));

// table_copy.wast:96
assert_trap(() => call($2, "check_t1", [20]));

// table_copy.wast:97
assert_trap(() => call($2, "check_t1", [21]));

// table_copy.wast:98
assert_trap(() => call($2, "check_t1", [22]));

// table_copy.wast:99
assert_trap(() => call($2, "check_t1", [23]));

// table_copy.wast:100
assert_trap(() => call($2, "check_t1", [24]));

// table_copy.wast:101
assert_trap(() => call($2, "check_t1", [25]));

// table_copy.wast:102
assert_trap(() => call($2, "check_t1", [26]));

// table_copy.wast:103
assert_trap(() => call($2, "check_t1", [27]));

// table_copy.wast:104
assert_trap(() => call($2, "check_t1", [28]));

// table_copy.wast:105
assert_trap(() => call($2, "check_t1", [29]));

// table_copy.wast:107
let $3 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x02\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:137
run(() => call($3, "test", []));

// table_copy.wast:138
assert_trap(() => call($3, "check_t0", [0]));

// table_copy.wast:139
assert_trap(() => call($3, "check_t0", [1]));

// table_copy.wast:140
assert_return(() => call($3, "check_t0", [2]), 3);

// table_copy.wast:141
assert_return(() => call($3, "check_t0", [3]), 1);

// table_copy.wast:142
assert_return(() => call($3, "check_t0", [4]), 4);

// table_copy.wast:143
assert_return(() => call($3, "check_t0", [5]), 1);

// table_copy.wast:144
assert_trap(() => call($3, "check_t0", [6]));

// table_copy.wast:145
assert_trap(() => call($3, "check_t0", [7]));

// table_copy.wast:146
assert_trap(() => call($3, "check_t0", [8]));

// table_copy.wast:147
assert_trap(() => call($3, "check_t0", [9]));

// table_copy.wast:148
assert_trap(() => call($3, "check_t0", [10]));

// table_copy.wast:149
assert_trap(() => call($3, "check_t0", [11]));

// table_copy.wast:150
assert_return(() => call($3, "check_t0", [12]), 7);

// table_copy.wast:151
assert_return(() => call($3, "check_t0", [13]), 3);

// table_copy.wast:152
assert_return(() => call($3, "check_t0", [14]), 1);

// table_copy.wast:153
assert_return(() => call($3, "check_t0", [15]), 4);

// table_copy.wast:154
assert_return(() => call($3, "check_t0", [16]), 6);

// table_copy.wast:155
assert_trap(() => call($3, "check_t0", [17]));

// table_copy.wast:156
assert_trap(() => call($3, "check_t0", [18]));

// table_copy.wast:157
assert_trap(() => call($3, "check_t0", [19]));

// table_copy.wast:158
assert_trap(() => call($3, "check_t0", [20]));

// table_copy.wast:159
assert_trap(() => call($3, "check_t0", [21]));

// table_copy.wast:160
assert_trap(() => call($3, "check_t0", [22]));

// table_copy.wast:161
assert_trap(() => call($3, "check_t0", [23]));

// table_copy.wast:162
assert_trap(() => call($3, "check_t0", [24]));

// table_copy.wast:163
assert_trap(() => call($3, "check_t0", [25]));

// table_copy.wast:164
assert_trap(() => call($3, "check_t0", [26]));

// table_copy.wast:165
assert_trap(() => call($3, "check_t0", [27]));

// table_copy.wast:166
assert_trap(() => call($3, "check_t0", [28]));

// table_copy.wast:167
assert_trap(() => call($3, "check_t0", [29]));

// table_copy.wast:168
assert_trap(() => call($3, "check_t1", [0]));

// table_copy.wast:169
assert_trap(() => call($3, "check_t1", [1]));

// table_copy.wast:170
assert_trap(() => call($3, "check_t1", [2]));

// table_copy.wast:171
assert_return(() => call($3, "check_t1", [3]), 1);

// table_copy.wast:172
assert_return(() => call($3, "check_t1", [4]), 3);

// table_copy.wast:173
assert_return(() => call($3, "check_t1", [5]), 1);

// table_copy.wast:174
assert_return(() => call($3, "check_t1", [6]), 4);

// table_copy.wast:175
assert_trap(() => call($3, "check_t1", [7]));

// table_copy.wast:176
assert_trap(() => call($3, "check_t1", [8]));

// table_copy.wast:177
assert_trap(() => call($3, "check_t1", [9]));

// table_copy.wast:178
assert_trap(() => call($3, "check_t1", [10]));

// table_copy.wast:179
assert_return(() => call($3, "check_t1", [11]), 6);

// table_copy.wast:180
assert_return(() => call($3, "check_t1", [12]), 3);

// table_copy.wast:181
assert_return(() => call($3, "check_t1", [13]), 2);

// table_copy.wast:182
assert_return(() => call($3, "check_t1", [14]), 5);

// table_copy.wast:183
assert_return(() => call($3, "check_t1", [15]), 7);

// table_copy.wast:184
assert_trap(() => call($3, "check_t1", [16]));

// table_copy.wast:185
assert_trap(() => call($3, "check_t1", [17]));

// table_copy.wast:186
assert_trap(() => call($3, "check_t1", [18]));

// table_copy.wast:187
assert_trap(() => call($3, "check_t1", [19]));

// table_copy.wast:188
assert_trap(() => call($3, "check_t1", [20]));

// table_copy.wast:189
assert_trap(() => call($3, "check_t1", [21]));

// table_copy.wast:190
assert_trap(() => call($3, "check_t1", [22]));

// table_copy.wast:191
assert_trap(() => call($3, "check_t1", [23]));

// table_copy.wast:192
assert_trap(() => call($3, "check_t1", [24]));

// table_copy.wast:193
assert_trap(() => call($3, "check_t1", [25]));

// table_copy.wast:194
assert_trap(() => call($3, "check_t1", [26]));

// table_copy.wast:195
assert_trap(() => call($3, "check_t1", [27]));

// table_copy.wast:196
assert_trap(() => call($3, "check_t1", [28]));

// table_copy.wast:197
assert_trap(() => call($3, "check_t1", [29]));

// table_copy.wast:199
let $4 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x0f\x41\x02\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:229
run(() => call($4, "test", []));

// table_copy.wast:230
assert_trap(() => call($4, "check_t0", [0]));

// table_copy.wast:231
assert_trap(() => call($4, "check_t0", [1]));

// table_copy.wast:232
assert_return(() => call($4, "check_t0", [2]), 3);

// table_copy.wast:233
assert_return(() => call($4, "check_t0", [3]), 1);

// table_copy.wast:234
assert_return(() => call($4, "check_t0", [4]), 4);

// table_copy.wast:235
assert_return(() => call($4, "check_t0", [5]), 1);

// table_copy.wast:236
assert_trap(() => call($4, "check_t0", [6]));

// table_copy.wast:237
assert_trap(() => call($4, "check_t0", [7]));

// table_copy.wast:238
assert_trap(() => call($4, "check_t0", [8]));

// table_copy.wast:239
assert_trap(() => call($4, "check_t0", [9]));

// table_copy.wast:240
assert_trap(() => call($4, "check_t0", [10]));

// table_copy.wast:241
assert_trap(() => call($4, "check_t0", [11]));

// table_copy.wast:242
assert_return(() => call($4, "check_t0", [12]), 7);

// table_copy.wast:243
assert_return(() => call($4, "check_t0", [13]), 5);

// table_copy.wast:244
assert_return(() => call($4, "check_t0", [14]), 2);

// table_copy.wast:245
assert_return(() => call($4, "check_t0", [15]), 3);

// table_copy.wast:246
assert_return(() => call($4, "check_t0", [16]), 6);

// table_copy.wast:247
assert_trap(() => call($4, "check_t0", [17]));

// table_copy.wast:248
assert_trap(() => call($4, "check_t0", [18]));

// table_copy.wast:249
assert_trap(() => call($4, "check_t0", [19]));

// table_copy.wast:250
assert_trap(() => call($4, "check_t0", [20]));

// table_copy.wast:251
assert_trap(() => call($4, "check_t0", [21]));

// table_copy.wast:252
assert_trap(() => call($4, "check_t0", [22]));

// table_copy.wast:253
assert_trap(() => call($4, "check_t0", [23]));

// table_copy.wast:254
assert_trap(() => call($4, "check_t0", [24]));

// table_copy.wast:255
assert_return(() => call($4, "check_t0", [25]), 3);

// table_copy.wast:256
assert_return(() => call($4, "check_t0", [26]), 6);

// table_copy.wast:257
assert_trap(() => call($4, "check_t0", [27]));

// table_copy.wast:258
assert_trap(() => call($4, "check_t0", [28]));

// table_copy.wast:259
assert_trap(() => call($4, "check_t0", [29]));

// table_copy.wast:260
assert_trap(() => call($4, "check_t1", [0]));

// table_copy.wast:261
assert_trap(() => call($4, "check_t1", [1]));

// table_copy.wast:262
assert_trap(() => call($4, "check_t1", [2]));

// table_copy.wast:263
assert_return(() => call($4, "check_t1", [3]), 1);

// table_copy.wast:264
assert_return(() => call($4, "check_t1", [4]), 3);

// table_copy.wast:265
assert_return(() => call($4, "check_t1", [5]), 1);

// table_copy.wast:266
assert_return(() => call($4, "check_t1", [6]), 4);

// table_copy.wast:267
assert_trap(() => call($4, "check_t1", [7]));

// table_copy.wast:268
assert_trap(() => call($4, "check_t1", [8]));

// table_copy.wast:269
assert_trap(() => call($4, "check_t1", [9]));

// table_copy.wast:270
assert_trap(() => call($4, "check_t1", [10]));

// table_copy.wast:271
assert_return(() => call($4, "check_t1", [11]), 6);

// table_copy.wast:272
assert_return(() => call($4, "check_t1", [12]), 3);

// table_copy.wast:273
assert_return(() => call($4, "check_t1", [13]), 2);

// table_copy.wast:274
assert_return(() => call($4, "check_t1", [14]), 5);

// table_copy.wast:275
assert_return(() => call($4, "check_t1", [15]), 7);

// table_copy.wast:276
assert_trap(() => call($4, "check_t1", [16]));

// table_copy.wast:277
assert_trap(() => call($4, "check_t1", [17]));

// table_copy.wast:278
assert_trap(() => call($4, "check_t1", [18]));

// table_copy.wast:279
assert_trap(() => call($4, "check_t1", [19]));

// table_copy.wast:280
assert_trap(() => call($4, "check_t1", [20]));

// table_copy.wast:281
assert_trap(() => call($4, "check_t1", [21]));

// table_copy.wast:282
assert_trap(() => call($4, "check_t1", [22]));

// table_copy.wast:283
assert_trap(() => call($4, "check_t1", [23]));

// table_copy.wast:284
assert_trap(() => call($4, "check_t1", [24]));

// table_copy.wast:285
assert_trap(() => call($4, "check_t1", [25]));

// table_copy.wast:286
assert_trap(() => call($4, "check_t1", [26]));

// table_copy.wast:287
assert_trap(() => call($4, "check_t1", [27]));

// table_copy.wast:288
assert_trap(() => call($4, "check_t1", [28]));

// table_copy.wast:289
assert_trap(() => call($4, "check_t1", [29]));

// table_copy.wast:291
let $5 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x19\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:321
run(() => call($5, "test", []));

// table_copy.wast:322
assert_trap(() => call($5, "check_t0", [0]));

// table_copy.wast:323
assert_trap(() => call($5, "check_t0", [1]));

// table_copy.wast:324
assert_return(() => call($5, "check_t0", [2]), 3);

// table_copy.wast:325
assert_return(() => call($5, "check_t0", [3]), 1);

// table_copy.wast:326
assert_return(() => call($5, "check_t0", [4]), 4);

// table_copy.wast:327
assert_return(() => call($5, "check_t0", [5]), 1);

// table_copy.wast:328
assert_trap(() => call($5, "check_t0", [6]));

// table_copy.wast:329
assert_trap(() => call($5, "check_t0", [7]));

// table_copy.wast:330
assert_trap(() => call($5, "check_t0", [8]));

// table_copy.wast:331
assert_trap(() => call($5, "check_t0", [9]));

// table_copy.wast:332
assert_trap(() => call($5, "check_t0", [10]));

// table_copy.wast:333
assert_trap(() => call($5, "check_t0", [11]));

// table_copy.wast:334
assert_return(() => call($5, "check_t0", [12]), 7);

// table_copy.wast:335
assert_trap(() => call($5, "check_t0", [13]));

// table_copy.wast:336
assert_trap(() => call($5, "check_t0", [14]));

// table_copy.wast:337
assert_trap(() => call($5, "check_t0", [15]));

// table_copy.wast:338
assert_return(() => call($5, "check_t0", [16]), 6);

// table_copy.wast:339
assert_trap(() => call($5, "check_t0", [17]));

// table_copy.wast:340
assert_trap(() => call($5, "check_t0", [18]));

// table_copy.wast:341
assert_trap(() => call($5, "check_t0", [19]));

// table_copy.wast:342
assert_trap(() => call($5, "check_t0", [20]));

// table_copy.wast:343
assert_trap(() => call($5, "check_t0", [21]));

// table_copy.wast:344
assert_trap(() => call($5, "check_t0", [22]));

// table_copy.wast:345
assert_trap(() => call($5, "check_t0", [23]));

// table_copy.wast:346
assert_trap(() => call($5, "check_t0", [24]));

// table_copy.wast:347
assert_trap(() => call($5, "check_t0", [25]));

// table_copy.wast:348
assert_trap(() => call($5, "check_t0", [26]));

// table_copy.wast:349
assert_trap(() => call($5, "check_t0", [27]));

// table_copy.wast:350
assert_trap(() => call($5, "check_t0", [28]));

// table_copy.wast:351
assert_trap(() => call($5, "check_t0", [29]));

// table_copy.wast:352
assert_trap(() => call($5, "check_t1", [0]));

// table_copy.wast:353
assert_trap(() => call($5, "check_t1", [1]));

// table_copy.wast:354
assert_trap(() => call($5, "check_t1", [2]));

// table_copy.wast:355
assert_return(() => call($5, "check_t1", [3]), 1);

// table_copy.wast:356
assert_return(() => call($5, "check_t1", [4]), 3);

// table_copy.wast:357
assert_return(() => call($5, "check_t1", [5]), 1);

// table_copy.wast:358
assert_return(() => call($5, "check_t1", [6]), 4);

// table_copy.wast:359
assert_trap(() => call($5, "check_t1", [7]));

// table_copy.wast:360
assert_trap(() => call($5, "check_t1", [8]));

// table_copy.wast:361
assert_trap(() => call($5, "check_t1", [9]));

// table_copy.wast:362
assert_trap(() => call($5, "check_t1", [10]));

// table_copy.wast:363
assert_return(() => call($5, "check_t1", [11]), 6);

// table_copy.wast:364
assert_return(() => call($5, "check_t1", [12]), 3);

// table_copy.wast:365
assert_return(() => call($5, "check_t1", [13]), 2);

// table_copy.wast:366
assert_return(() => call($5, "check_t1", [14]), 5);

// table_copy.wast:367
assert_return(() => call($5, "check_t1", [15]), 7);

// table_copy.wast:368
assert_trap(() => call($5, "check_t1", [16]));

// table_copy.wast:369
assert_trap(() => call($5, "check_t1", [17]));

// table_copy.wast:370
assert_trap(() => call($5, "check_t1", [18]));

// table_copy.wast:371
assert_trap(() => call($5, "check_t1", [19]));

// table_copy.wast:372
assert_trap(() => call($5, "check_t1", [20]));

// table_copy.wast:373
assert_trap(() => call($5, "check_t1", [21]));

// table_copy.wast:374
assert_trap(() => call($5, "check_t1", [22]));

// table_copy.wast:375
assert_trap(() => call($5, "check_t1", [23]));

// table_copy.wast:376
assert_trap(() => call($5, "check_t1", [24]));

// table_copy.wast:377
assert_trap(() => call($5, "check_t1", [25]));

// table_copy.wast:378
assert_trap(() => call($5, "check_t1", [26]));

// table_copy.wast:379
assert_trap(() => call($5, "check_t1", [27]));

// table_copy.wast:380
assert_trap(() => call($5, "check_t1", [28]));

// table_copy.wast:381
assert_trap(() => call($5, "check_t1", [29]));

// table_copy.wast:383
let $6 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x14\x41\x16\x41\x04\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:413
run(() => call($6, "test", []));

// table_copy.wast:414
assert_trap(() => call($6, "check_t0", [0]));

// table_copy.wast:415
assert_trap(() => call($6, "check_t0", [1]));

// table_copy.wast:416
assert_return(() => call($6, "check_t0", [2]), 3);

// table_copy.wast:417
assert_return(() => call($6, "check_t0", [3]), 1);

// table_copy.wast:418
assert_return(() => call($6, "check_t0", [4]), 4);

// table_copy.wast:419
assert_return(() => call($6, "check_t0", [5]), 1);

// table_copy.wast:420
assert_trap(() => call($6, "check_t0", [6]));

// table_copy.wast:421
assert_trap(() => call($6, "check_t0", [7]));

// table_copy.wast:422
assert_trap(() => call($6, "check_t0", [8]));

// table_copy.wast:423
assert_trap(() => call($6, "check_t0", [9]));

// table_copy.wast:424
assert_trap(() => call($6, "check_t0", [10]));

// table_copy.wast:425
assert_trap(() => call($6, "check_t0", [11]));

// table_copy.wast:426
assert_return(() => call($6, "check_t0", [12]), 7);

// table_copy.wast:427
assert_return(() => call($6, "check_t0", [13]), 5);

// table_copy.wast:428
assert_return(() => call($6, "check_t0", [14]), 2);

// table_copy.wast:429
assert_return(() => call($6, "check_t0", [15]), 3);

// table_copy.wast:430
assert_return(() => call($6, "check_t0", [16]), 6);

// table_copy.wast:431
assert_trap(() => call($6, "check_t0", [17]));

// table_copy.wast:432
assert_trap(() => call($6, "check_t0", [18]));

// table_copy.wast:433
assert_trap(() => call($6, "check_t0", [19]));

// table_copy.wast:434
assert_trap(() => call($6, "check_t0", [20]));

// table_copy.wast:435
assert_trap(() => call($6, "check_t0", [21]));

// table_copy.wast:436
assert_trap(() => call($6, "check_t0", [22]));

// table_copy.wast:437
assert_trap(() => call($6, "check_t0", [23]));

// table_copy.wast:438
assert_trap(() => call($6, "check_t0", [24]));

// table_copy.wast:439
assert_trap(() => call($6, "check_t0", [25]));

// table_copy.wast:440
assert_trap(() => call($6, "check_t0", [26]));

// table_copy.wast:441
assert_trap(() => call($6, "check_t0", [27]));

// table_copy.wast:442
assert_trap(() => call($6, "check_t0", [28]));

// table_copy.wast:443
assert_trap(() => call($6, "check_t0", [29]));

// table_copy.wast:444
assert_trap(() => call($6, "check_t1", [0]));

// table_copy.wast:445
assert_trap(() => call($6, "check_t1", [1]));

// table_copy.wast:446
assert_trap(() => call($6, "check_t1", [2]));

// table_copy.wast:447
assert_return(() => call($6, "check_t1", [3]), 1);

// table_copy.wast:448
assert_return(() => call($6, "check_t1", [4]), 3);

// table_copy.wast:449
assert_return(() => call($6, "check_t1", [5]), 1);

// table_copy.wast:450
assert_return(() => call($6, "check_t1", [6]), 4);

// table_copy.wast:451
assert_trap(() => call($6, "check_t1", [7]));

// table_copy.wast:452
assert_trap(() => call($6, "check_t1", [8]));

// table_copy.wast:453
assert_trap(() => call($6, "check_t1", [9]));

// table_copy.wast:454
assert_trap(() => call($6, "check_t1", [10]));

// table_copy.wast:455
assert_return(() => call($6, "check_t1", [11]), 6);

// table_copy.wast:456
assert_return(() => call($6, "check_t1", [12]), 3);

// table_copy.wast:457
assert_return(() => call($6, "check_t1", [13]), 2);

// table_copy.wast:458
assert_return(() => call($6, "check_t1", [14]), 5);

// table_copy.wast:459
assert_return(() => call($6, "check_t1", [15]), 7);

// table_copy.wast:460
assert_trap(() => call($6, "check_t1", [16]));

// table_copy.wast:461
assert_trap(() => call($6, "check_t1", [17]));

// table_copy.wast:462
assert_trap(() => call($6, "check_t1", [18]));

// table_copy.wast:463
assert_trap(() => call($6, "check_t1", [19]));

// table_copy.wast:464
assert_trap(() => call($6, "check_t1", [20]));

// table_copy.wast:465
assert_trap(() => call($6, "check_t1", [21]));

// table_copy.wast:466
assert_trap(() => call($6, "check_t1", [22]));

// table_copy.wast:467
assert_trap(() => call($6, "check_t1", [23]));

// table_copy.wast:468
assert_trap(() => call($6, "check_t1", [24]));

// table_copy.wast:469
assert_trap(() => call($6, "check_t1", [25]));

// table_copy.wast:470
assert_trap(() => call($6, "check_t1", [26]));

// table_copy.wast:471
assert_trap(() => call($6, "check_t1", [27]));

// table_copy.wast:472
assert_trap(() => call($6, "check_t1", [28]));

// table_copy.wast:473
assert_trap(() => call($6, "check_t1", [29]));

// table_copy.wast:475
let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x01\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:505
run(() => call($7, "test", []));

// table_copy.wast:506
assert_trap(() => call($7, "check_t0", [0]));

// table_copy.wast:507
assert_trap(() => call($7, "check_t0", [1]));

// table_copy.wast:508
assert_return(() => call($7, "check_t0", [2]), 3);

// table_copy.wast:509
assert_return(() => call($7, "check_t0", [3]), 1);

// table_copy.wast:510
assert_return(() => call($7, "check_t0", [4]), 4);

// table_copy.wast:511
assert_return(() => call($7, "check_t0", [5]), 1);

// table_copy.wast:512
assert_trap(() => call($7, "check_t0", [6]));

// table_copy.wast:513
assert_trap(() => call($7, "check_t0", [7]));

// table_copy.wast:514
assert_trap(() => call($7, "check_t0", [8]));

// table_copy.wast:515
assert_trap(() => call($7, "check_t0", [9]));

// table_copy.wast:516
assert_trap(() => call($7, "check_t0", [10]));

// table_copy.wast:517
assert_trap(() => call($7, "check_t0", [11]));

// table_copy.wast:518
assert_return(() => call($7, "check_t0", [12]), 7);

// table_copy.wast:519
assert_return(() => call($7, "check_t0", [13]), 5);

// table_copy.wast:520
assert_return(() => call($7, "check_t0", [14]), 2);

// table_copy.wast:521
assert_return(() => call($7, "check_t0", [15]), 3);

// table_copy.wast:522
assert_return(() => call($7, "check_t0", [16]), 6);

// table_copy.wast:523
assert_trap(() => call($7, "check_t0", [17]));

// table_copy.wast:524
assert_trap(() => call($7, "check_t0", [18]));

// table_copy.wast:525
assert_trap(() => call($7, "check_t0", [19]));

// table_copy.wast:526
assert_trap(() => call($7, "check_t0", [20]));

// table_copy.wast:527
assert_trap(() => call($7, "check_t0", [21]));

// table_copy.wast:528
assert_trap(() => call($7, "check_t0", [22]));

// table_copy.wast:529
assert_trap(() => call($7, "check_t0", [23]));

// table_copy.wast:530
assert_trap(() => call($7, "check_t0", [24]));

// table_copy.wast:531
assert_trap(() => call($7, "check_t0", [25]));

// table_copy.wast:532
assert_return(() => call($7, "check_t0", [26]), 3);

// table_copy.wast:533
assert_return(() => call($7, "check_t0", [27]), 1);

// table_copy.wast:534
assert_trap(() => call($7, "check_t0", [28]));

// table_copy.wast:535
assert_trap(() => call($7, "check_t0", [29]));

// table_copy.wast:536
assert_trap(() => call($7, "check_t1", [0]));

// table_copy.wast:537
assert_trap(() => call($7, "check_t1", [1]));

// table_copy.wast:538
assert_trap(() => call($7, "check_t1", [2]));

// table_copy.wast:539
assert_return(() => call($7, "check_t1", [3]), 1);

// table_copy.wast:540
assert_return(() => call($7, "check_t1", [4]), 3);

// table_copy.wast:541
assert_return(() => call($7, "check_t1", [5]), 1);

// table_copy.wast:542
assert_return(() => call($7, "check_t1", [6]), 4);

// table_copy.wast:543
assert_trap(() => call($7, "check_t1", [7]));

// table_copy.wast:544
assert_trap(() => call($7, "check_t1", [8]));

// table_copy.wast:545
assert_trap(() => call($7, "check_t1", [9]));

// table_copy.wast:546
assert_trap(() => call($7, "check_t1", [10]));

// table_copy.wast:547
assert_return(() => call($7, "check_t1", [11]), 6);

// table_copy.wast:548
assert_return(() => call($7, "check_t1", [12]), 3);

// table_copy.wast:549
assert_return(() => call($7, "check_t1", [13]), 2);

// table_copy.wast:550
assert_return(() => call($7, "check_t1", [14]), 5);

// table_copy.wast:551
assert_return(() => call($7, "check_t1", [15]), 7);

// table_copy.wast:552
assert_trap(() => call($7, "check_t1", [16]));

// table_copy.wast:553
assert_trap(() => call($7, "check_t1", [17]));

// table_copy.wast:554
assert_trap(() => call($7, "check_t1", [18]));

// table_copy.wast:555
assert_trap(() => call($7, "check_t1", [19]));

// table_copy.wast:556
assert_trap(() => call($7, "check_t1", [20]));

// table_copy.wast:557
assert_trap(() => call($7, "check_t1", [21]));

// table_copy.wast:558
assert_trap(() => call($7, "check_t1", [22]));

// table_copy.wast:559
assert_trap(() => call($7, "check_t1", [23]));

// table_copy.wast:560
assert_trap(() => call($7, "check_t1", [24]));

// table_copy.wast:561
assert_trap(() => call($7, "check_t1", [25]));

// table_copy.wast:562
assert_trap(() => call($7, "check_t1", [26]));

// table_copy.wast:563
assert_trap(() => call($7, "check_t1", [27]));

// table_copy.wast:564
assert_trap(() => call($7, "check_t1", [28]));

// table_copy.wast:565
assert_trap(() => call($7, "check_t1", [29]));

// table_copy.wast:567
let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x0c\x41\x07\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:597
run(() => call($8, "test", []));

// table_copy.wast:598
assert_trap(() => call($8, "check_t0", [0]));

// table_copy.wast:599
assert_trap(() => call($8, "check_t0", [1]));

// table_copy.wast:600
assert_return(() => call($8, "check_t0", [2]), 3);

// table_copy.wast:601
assert_return(() => call($8, "check_t0", [3]), 1);

// table_copy.wast:602
assert_return(() => call($8, "check_t0", [4]), 4);

// table_copy.wast:603
assert_return(() => call($8, "check_t0", [5]), 1);

// table_copy.wast:604
assert_trap(() => call($8, "check_t0", [6]));

// table_copy.wast:605
assert_trap(() => call($8, "check_t0", [7]));

// table_copy.wast:606
assert_trap(() => call($8, "check_t0", [8]));

// table_copy.wast:607
assert_trap(() => call($8, "check_t0", [9]));

// table_copy.wast:608
assert_return(() => call($8, "check_t0", [10]), 7);

// table_copy.wast:609
assert_return(() => call($8, "check_t0", [11]), 5);

// table_copy.wast:610
assert_return(() => call($8, "check_t0", [12]), 2);

// table_copy.wast:611
assert_return(() => call($8, "check_t0", [13]), 3);

// table_copy.wast:612
assert_return(() => call($8, "check_t0", [14]), 6);

// table_copy.wast:613
assert_trap(() => call($8, "check_t0", [15]));

// table_copy.wast:614
assert_trap(() => call($8, "check_t0", [16]));

// table_copy.wast:615
assert_trap(() => call($8, "check_t0", [17]));

// table_copy.wast:616
assert_trap(() => call($8, "check_t0", [18]));

// table_copy.wast:617
assert_trap(() => call($8, "check_t0", [19]));

// table_copy.wast:618
assert_trap(() => call($8, "check_t0", [20]));

// table_copy.wast:619
assert_trap(() => call($8, "check_t0", [21]));

// table_copy.wast:620
assert_trap(() => call($8, "check_t0", [22]));

// table_copy.wast:621
assert_trap(() => call($8, "check_t0", [23]));

// table_copy.wast:622
assert_trap(() => call($8, "check_t0", [24]));

// table_copy.wast:623
assert_trap(() => call($8, "check_t0", [25]));

// table_copy.wast:624
assert_trap(() => call($8, "check_t0", [26]));

// table_copy.wast:625
assert_trap(() => call($8, "check_t0", [27]));

// table_copy.wast:626
assert_trap(() => call($8, "check_t0", [28]));

// table_copy.wast:627
assert_trap(() => call($8, "check_t0", [29]));

// table_copy.wast:628
assert_trap(() => call($8, "check_t1", [0]));

// table_copy.wast:629
assert_trap(() => call($8, "check_t1", [1]));

// table_copy.wast:630
assert_trap(() => call($8, "check_t1", [2]));

// table_copy.wast:631
assert_return(() => call($8, "check_t1", [3]), 1);

// table_copy.wast:632
assert_return(() => call($8, "check_t1", [4]), 3);

// table_copy.wast:633
assert_return(() => call($8, "check_t1", [5]), 1);

// table_copy.wast:634
assert_return(() => call($8, "check_t1", [6]), 4);

// table_copy.wast:635
assert_trap(() => call($8, "check_t1", [7]));

// table_copy.wast:636
assert_trap(() => call($8, "check_t1", [8]));

// table_copy.wast:637
assert_trap(() => call($8, "check_t1", [9]));

// table_copy.wast:638
assert_trap(() => call($8, "check_t1", [10]));

// table_copy.wast:639
assert_return(() => call($8, "check_t1", [11]), 6);

// table_copy.wast:640
assert_return(() => call($8, "check_t1", [12]), 3);

// table_copy.wast:641
assert_return(() => call($8, "check_t1", [13]), 2);

// table_copy.wast:642
assert_return(() => call($8, "check_t1", [14]), 5);

// table_copy.wast:643
assert_return(() => call($8, "check_t1", [15]), 7);

// table_copy.wast:644
assert_trap(() => call($8, "check_t1", [16]));

// table_copy.wast:645
assert_trap(() => call($8, "check_t1", [17]));

// table_copy.wast:646
assert_trap(() => call($8, "check_t1", [18]));

// table_copy.wast:647
assert_trap(() => call($8, "check_t1", [19]));

// table_copy.wast:648
assert_trap(() => call($8, "check_t1", [20]));

// table_copy.wast:649
assert_trap(() => call($8, "check_t1", [21]));

// table_copy.wast:650
assert_trap(() => call($8, "check_t1", [22]));

// table_copy.wast:651
assert_trap(() => call($8, "check_t1", [23]));

// table_copy.wast:652
assert_trap(() => call($8, "check_t1", [24]));

// table_copy.wast:653
assert_trap(() => call($8, "check_t1", [25]));

// table_copy.wast:654
assert_trap(() => call($8, "check_t1", [26]));

// table_copy.wast:655
assert_trap(() => call($8, "check_t1", [27]));

// table_copy.wast:656
assert_trap(() => call($8, "check_t1", [28]));

// table_copy.wast:657
assert_trap(() => call($8, "check_t1", [29]));

// table_copy.wast:659
let $9 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x0a\x41\x07\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:689
run(() => call($9, "test", []));

// table_copy.wast:690
assert_trap(() => call($9, "check_t0", [0]));

// table_copy.wast:691
assert_trap(() => call($9, "check_t0", [1]));

// table_copy.wast:692
assert_return(() => call($9, "check_t0", [2]), 3);

// table_copy.wast:693
assert_return(() => call($9, "check_t0", [3]), 1);

// table_copy.wast:694
assert_return(() => call($9, "check_t0", [4]), 4);

// table_copy.wast:695
assert_return(() => call($9, "check_t0", [5]), 1);

// table_copy.wast:696
assert_trap(() => call($9, "check_t0", [6]));

// table_copy.wast:697
assert_trap(() => call($9, "check_t0", [7]));

// table_copy.wast:698
assert_trap(() => call($9, "check_t0", [8]));

// table_copy.wast:699
assert_trap(() => call($9, "check_t0", [9]));

// table_copy.wast:700
assert_trap(() => call($9, "check_t0", [10]));

// table_copy.wast:701
assert_trap(() => call($9, "check_t0", [11]));

// table_copy.wast:702
assert_trap(() => call($9, "check_t0", [12]));

// table_copy.wast:703
assert_trap(() => call($9, "check_t0", [13]));

// table_copy.wast:704
assert_return(() => call($9, "check_t0", [14]), 7);

// table_copy.wast:705
assert_return(() => call($9, "check_t0", [15]), 5);

// table_copy.wast:706
assert_return(() => call($9, "check_t0", [16]), 2);

// table_copy.wast:707
assert_return(() => call($9, "check_t0", [17]), 3);

// table_copy.wast:708
assert_return(() => call($9, "check_t0", [18]), 6);

// table_copy.wast:709
assert_trap(() => call($9, "check_t0", [19]));

// table_copy.wast:710
assert_trap(() => call($9, "check_t0", [20]));

// table_copy.wast:711
assert_trap(() => call($9, "check_t0", [21]));

// table_copy.wast:712
assert_trap(() => call($9, "check_t0", [22]));

// table_copy.wast:713
assert_trap(() => call($9, "check_t0", [23]));

// table_copy.wast:714
assert_trap(() => call($9, "check_t0", [24]));

// table_copy.wast:715
assert_trap(() => call($9, "check_t0", [25]));

// table_copy.wast:716
assert_trap(() => call($9, "check_t0", [26]));

// table_copy.wast:717
assert_trap(() => call($9, "check_t0", [27]));

// table_copy.wast:718
assert_trap(() => call($9, "check_t0", [28]));

// table_copy.wast:719
assert_trap(() => call($9, "check_t0", [29]));

// table_copy.wast:720
assert_trap(() => call($9, "check_t1", [0]));

// table_copy.wast:721
assert_trap(() => call($9, "check_t1", [1]));

// table_copy.wast:722
assert_trap(() => call($9, "check_t1", [2]));

// table_copy.wast:723
assert_return(() => call($9, "check_t1", [3]), 1);

// table_copy.wast:724
assert_return(() => call($9, "check_t1", [4]), 3);

// table_copy.wast:725
assert_return(() => call($9, "check_t1", [5]), 1);

// table_copy.wast:726
assert_return(() => call($9, "check_t1", [6]), 4);

// table_copy.wast:727
assert_trap(() => call($9, "check_t1", [7]));

// table_copy.wast:728
assert_trap(() => call($9, "check_t1", [8]));

// table_copy.wast:729
assert_trap(() => call($9, "check_t1", [9]));

// table_copy.wast:730
assert_trap(() => call($9, "check_t1", [10]));

// table_copy.wast:731
assert_return(() => call($9, "check_t1", [11]), 6);

// table_copy.wast:732
assert_return(() => call($9, "check_t1", [12]), 3);

// table_copy.wast:733
assert_return(() => call($9, "check_t1", [13]), 2);

// table_copy.wast:734
assert_return(() => call($9, "check_t1", [14]), 5);

// table_copy.wast:735
assert_return(() => call($9, "check_t1", [15]), 7);

// table_copy.wast:736
assert_trap(() => call($9, "check_t1", [16]));

// table_copy.wast:737
assert_trap(() => call($9, "check_t1", [17]));

// table_copy.wast:738
assert_trap(() => call($9, "check_t1", [18]));

// table_copy.wast:739
assert_trap(() => call($9, "check_t1", [19]));

// table_copy.wast:740
assert_trap(() => call($9, "check_t1", [20]));

// table_copy.wast:741
assert_trap(() => call($9, "check_t1", [21]));

// table_copy.wast:742
assert_trap(() => call($9, "check_t1", [22]));

// table_copy.wast:743
assert_trap(() => call($9, "check_t1", [23]));

// table_copy.wast:744
assert_trap(() => call($9, "check_t1", [24]));

// table_copy.wast:745
assert_trap(() => call($9, "check_t1", [25]));

// table_copy.wast:746
assert_trap(() => call($9, "check_t1", [26]));

// table_copy.wast:747
assert_trap(() => call($9, "check_t1", [27]));

// table_copy.wast:748
assert_trap(() => call($9, "check_t1", [28]));

// table_copy.wast:749
assert_trap(() => call($9, "check_t1", [29]));

// table_copy.wast:751
let $10 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x00\x41\x14\xfc\x0e\x01\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:781
run(() => call($10, "test", []));

// table_copy.wast:782
assert_trap(() => call($10, "check_t0", [0]));

// table_copy.wast:783
assert_trap(() => call($10, "check_t0", [1]));

// table_copy.wast:784
assert_return(() => call($10, "check_t0", [2]), 3);

// table_copy.wast:785
assert_return(() => call($10, "check_t0", [3]), 1);

// table_copy.wast:786
assert_return(() => call($10, "check_t0", [4]), 4);

// table_copy.wast:787
assert_return(() => call($10, "check_t0", [5]), 1);

// table_copy.wast:788
assert_trap(() => call($10, "check_t0", [6]));

// table_copy.wast:789
assert_trap(() => call($10, "check_t0", [7]));

// table_copy.wast:790
assert_trap(() => call($10, "check_t0", [8]));

// table_copy.wast:791
assert_trap(() => call($10, "check_t0", [9]));

// table_copy.wast:792
assert_trap(() => call($10, "check_t0", [10]));

// table_copy.wast:793
assert_trap(() => call($10, "check_t0", [11]));

// table_copy.wast:794
assert_return(() => call($10, "check_t0", [12]), 7);

// table_copy.wast:795
assert_return(() => call($10, "check_t0", [13]), 5);

// table_copy.wast:796
assert_return(() => call($10, "check_t0", [14]), 2);

// table_copy.wast:797
assert_return(() => call($10, "check_t0", [15]), 3);

// table_copy.wast:798
assert_return(() => call($10, "check_t0", [16]), 6);

// table_copy.wast:799
assert_trap(() => call($10, "check_t0", [17]));

// table_copy.wast:800
assert_trap(() => call($10, "check_t0", [18]));

// table_copy.wast:801
assert_trap(() => call($10, "check_t0", [19]));

// table_copy.wast:802
assert_trap(() => call($10, "check_t0", [20]));

// table_copy.wast:803
assert_trap(() => call($10, "check_t0", [21]));

// table_copy.wast:804
assert_trap(() => call($10, "check_t0", [22]));

// table_copy.wast:805
assert_trap(() => call($10, "check_t0", [23]));

// table_copy.wast:806
assert_trap(() => call($10, "check_t0", [24]));

// table_copy.wast:807
assert_trap(() => call($10, "check_t0", [25]));

// table_copy.wast:808
assert_trap(() => call($10, "check_t0", [26]));

// table_copy.wast:809
assert_trap(() => call($10, "check_t0", [27]));

// table_copy.wast:810
assert_trap(() => call($10, "check_t0", [28]));

// table_copy.wast:811
assert_trap(() => call($10, "check_t0", [29]));

// table_copy.wast:812
assert_trap(() => call($10, "check_t1", [0]));

// table_copy.wast:813
assert_trap(() => call($10, "check_t1", [1]));

// table_copy.wast:814
assert_trap(() => call($10, "check_t1", [2]));

// table_copy.wast:815
assert_return(() => call($10, "check_t1", [3]), 1);

// table_copy.wast:816
assert_return(() => call($10, "check_t1", [4]), 3);

// table_copy.wast:817
assert_return(() => call($10, "check_t1", [5]), 1);

// table_copy.wast:818
assert_return(() => call($10, "check_t1", [6]), 4);

// table_copy.wast:819
assert_trap(() => call($10, "check_t1", [7]));

// table_copy.wast:820
assert_trap(() => call($10, "check_t1", [8]));

// table_copy.wast:821
assert_trap(() => call($10, "check_t1", [9]));

// table_copy.wast:822
assert_trap(() => call($10, "check_t1", [10]));

// table_copy.wast:823
assert_trap(() => call($10, "check_t1", [11]));

// table_copy.wast:824
assert_return(() => call($10, "check_t1", [12]), 3);

// table_copy.wast:825
assert_return(() => call($10, "check_t1", [13]), 1);

// table_copy.wast:826
assert_return(() => call($10, "check_t1", [14]), 4);

// table_copy.wast:827
assert_return(() => call($10, "check_t1", [15]), 1);

// table_copy.wast:828
assert_trap(() => call($10, "check_t1", [16]));

// table_copy.wast:829
assert_trap(() => call($10, "check_t1", [17]));

// table_copy.wast:830
assert_trap(() => call($10, "check_t1", [18]));

// table_copy.wast:831
assert_trap(() => call($10, "check_t1", [19]));

// table_copy.wast:832
assert_trap(() => call($10, "check_t1", [20]));

// table_copy.wast:833
assert_trap(() => call($10, "check_t1", [21]));

// table_copy.wast:834
assert_return(() => call($10, "check_t1", [22]), 7);

// table_copy.wast:835
assert_return(() => call($10, "check_t1", [23]), 5);

// table_copy.wast:836
assert_return(() => call($10, "check_t1", [24]), 2);

// table_copy.wast:837
assert_return(() => call($10, "check_t1", [25]), 3);

// table_copy.wast:838
assert_return(() => call($10, "check_t1", [26]), 6);

// table_copy.wast:839
assert_trap(() => call($10, "check_t1", [27]));

// table_copy.wast:840
assert_trap(() => call($10, "check_t1", [28]));

// table_copy.wast:841
assert_trap(() => call($10, "check_t1", [29]));

// table_copy.wast:843
let $11 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xce\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x83\x80\x80\x80\x00\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:873
run(() => call($11, "test", []));

// table_copy.wast:874
assert_trap(() => call($11, "check_t0", [0]));

// table_copy.wast:875
assert_trap(() => call($11, "check_t0", [1]));

// table_copy.wast:876
assert_return(() => call($11, "check_t0", [2]), 3);

// table_copy.wast:877
assert_return(() => call($11, "check_t0", [3]), 1);

// table_copy.wast:878
assert_return(() => call($11, "check_t0", [4]), 4);

// table_copy.wast:879
assert_return(() => call($11, "check_t0", [5]), 1);

// table_copy.wast:880
assert_trap(() => call($11, "check_t0", [6]));

// table_copy.wast:881
assert_trap(() => call($11, "check_t0", [7]));

// table_copy.wast:882
assert_trap(() => call($11, "check_t0", [8]));

// table_copy.wast:883
assert_trap(() => call($11, "check_t0", [9]));

// table_copy.wast:884
assert_trap(() => call($11, "check_t0", [10]));

// table_copy.wast:885
assert_trap(() => call($11, "check_t0", [11]));

// table_copy.wast:886
assert_return(() => call($11, "check_t0", [12]), 7);

// table_copy.wast:887
assert_return(() => call($11, "check_t0", [13]), 5);

// table_copy.wast:888
assert_return(() => call($11, "check_t0", [14]), 2);

// table_copy.wast:889
assert_return(() => call($11, "check_t0", [15]), 3);

// table_copy.wast:890
assert_return(() => call($11, "check_t0", [16]), 6);

// table_copy.wast:891
assert_trap(() => call($11, "check_t0", [17]));

// table_copy.wast:892
assert_trap(() => call($11, "check_t0", [18]));

// table_copy.wast:893
assert_trap(() => call($11, "check_t0", [19]));

// table_copy.wast:894
assert_trap(() => call($11, "check_t0", [20]));

// table_copy.wast:895
assert_trap(() => call($11, "check_t0", [21]));

// table_copy.wast:896
assert_trap(() => call($11, "check_t0", [22]));

// table_copy.wast:897
assert_trap(() => call($11, "check_t0", [23]));

// table_copy.wast:898
assert_trap(() => call($11, "check_t0", [24]));

// table_copy.wast:899
assert_trap(() => call($11, "check_t0", [25]));

// table_copy.wast:900
assert_trap(() => call($11, "check_t0", [26]));

// table_copy.wast:901
assert_trap(() => call($11, "check_t0", [27]));

// table_copy.wast:902
assert_trap(() => call($11, "check_t0", [28]));

// table_copy.wast:903
assert_trap(() => call($11, "check_t0", [29]));

// table_copy.wast:904
assert_trap(() => call($11, "check_t1", [0]));

// table_copy.wast:905
assert_trap(() => call($11, "check_t1", [1]));

// table_copy.wast:906
assert_trap(() => call($11, "check_t1", [2]));

// table_copy.wast:907
assert_return(() => call($11, "check_t1", [3]), 1);

// table_copy.wast:908
assert_return(() => call($11, "check_t1", [4]), 3);

// table_copy.wast:909
assert_return(() => call($11, "check_t1", [5]), 1);

// table_copy.wast:910
assert_return(() => call($11, "check_t1", [6]), 4);

// table_copy.wast:911
assert_trap(() => call($11, "check_t1", [7]));

// table_copy.wast:912
assert_trap(() => call($11, "check_t1", [8]));

// table_copy.wast:913
assert_trap(() => call($11, "check_t1", [9]));

// table_copy.wast:914
assert_trap(() => call($11, "check_t1", [10]));

// table_copy.wast:915
assert_return(() => call($11, "check_t1", [11]), 6);

// table_copy.wast:916
assert_return(() => call($11, "check_t1", [12]), 3);

// table_copy.wast:917
assert_return(() => call($11, "check_t1", [13]), 2);

// table_copy.wast:918
assert_return(() => call($11, "check_t1", [14]), 5);

// table_copy.wast:919
assert_return(() => call($11, "check_t1", [15]), 7);

// table_copy.wast:920
assert_trap(() => call($11, "check_t1", [16]));

// table_copy.wast:921
assert_trap(() => call($11, "check_t1", [17]));

// table_copy.wast:922
assert_trap(() => call($11, "check_t1", [18]));

// table_copy.wast:923
assert_trap(() => call($11, "check_t1", [19]));

// table_copy.wast:924
assert_trap(() => call($11, "check_t1", [20]));

// table_copy.wast:925
assert_trap(() => call($11, "check_t1", [21]));

// table_copy.wast:926
assert_trap(() => call($11, "check_t1", [22]));

// table_copy.wast:927
assert_trap(() => call($11, "check_t1", [23]));

// table_copy.wast:928
assert_trap(() => call($11, "check_t1", [24]));

// table_copy.wast:929
assert_trap(() => call($11, "check_t1", [25]));

// table_copy.wast:930
assert_trap(() => call($11, "check_t1", [26]));

// table_copy.wast:931
assert_trap(() => call($11, "check_t1", [27]));

// table_copy.wast:932
assert_trap(() => call($11, "check_t1", [28]));

// table_copy.wast:933
assert_trap(() => call($11, "check_t1", [29]));

// table_copy.wast:935
let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x02\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:965
run(() => call($12, "test", []));

// table_copy.wast:966
assert_trap(() => call($12, "check_t0", [0]));

// table_copy.wast:967
assert_trap(() => call($12, "check_t0", [1]));

// table_copy.wast:968
assert_return(() => call($12, "check_t0", [2]), 3);

// table_copy.wast:969
assert_return(() => call($12, "check_t0", [3]), 1);

// table_copy.wast:970
assert_return(() => call($12, "check_t0", [4]), 4);

// table_copy.wast:971
assert_return(() => call($12, "check_t0", [5]), 1);

// table_copy.wast:972
assert_trap(() => call($12, "check_t0", [6]));

// table_copy.wast:973
assert_trap(() => call($12, "check_t0", [7]));

// table_copy.wast:974
assert_trap(() => call($12, "check_t0", [8]));

// table_copy.wast:975
assert_trap(() => call($12, "check_t0", [9]));

// table_copy.wast:976
assert_trap(() => call($12, "check_t0", [10]));

// table_copy.wast:977
assert_trap(() => call($12, "check_t0", [11]));

// table_copy.wast:978
assert_return(() => call($12, "check_t0", [12]), 7);

// table_copy.wast:979
assert_return(() => call($12, "check_t0", [13]), 3);

// table_copy.wast:980
assert_return(() => call($12, "check_t0", [14]), 1);

// table_copy.wast:981
assert_return(() => call($12, "check_t0", [15]), 4);

// table_copy.wast:982
assert_return(() => call($12, "check_t0", [16]), 6);

// table_copy.wast:983
assert_trap(() => call($12, "check_t0", [17]));

// table_copy.wast:984
assert_trap(() => call($12, "check_t0", [18]));

// table_copy.wast:985
assert_trap(() => call($12, "check_t0", [19]));

// table_copy.wast:986
assert_trap(() => call($12, "check_t0", [20]));

// table_copy.wast:987
assert_trap(() => call($12, "check_t0", [21]));

// table_copy.wast:988
assert_trap(() => call($12, "check_t0", [22]));

// table_copy.wast:989
assert_trap(() => call($12, "check_t0", [23]));

// table_copy.wast:990
assert_trap(() => call($12, "check_t0", [24]));

// table_copy.wast:991
assert_trap(() => call($12, "check_t0", [25]));

// table_copy.wast:992
assert_trap(() => call($12, "check_t0", [26]));

// table_copy.wast:993
assert_trap(() => call($12, "check_t0", [27]));

// table_copy.wast:994
assert_trap(() => call($12, "check_t0", [28]));

// table_copy.wast:995
assert_trap(() => call($12, "check_t0", [29]));

// table_copy.wast:996
assert_trap(() => call($12, "check_t1", [0]));

// table_copy.wast:997
assert_trap(() => call($12, "check_t1", [1]));

// table_copy.wast:998
assert_trap(() => call($12, "check_t1", [2]));

// table_copy.wast:999
assert_return(() => call($12, "check_t1", [3]), 1);

// table_copy.wast:1000
assert_return(() => call($12, "check_t1", [4]), 3);

// table_copy.wast:1001
assert_return(() => call($12, "check_t1", [5]), 1);

// table_copy.wast:1002
assert_return(() => call($12, "check_t1", [6]), 4);

// table_copy.wast:1003
assert_trap(() => call($12, "check_t1", [7]));

// table_copy.wast:1004
assert_trap(() => call($12, "check_t1", [8]));

// table_copy.wast:1005
assert_trap(() => call($12, "check_t1", [9]));

// table_copy.wast:1006
assert_trap(() => call($12, "check_t1", [10]));

// table_copy.wast:1007
assert_return(() => call($12, "check_t1", [11]), 6);

// table_copy.wast:1008
assert_return(() => call($12, "check_t1", [12]), 3);

// table_copy.wast:1009
assert_return(() => call($12, "check_t1", [13]), 2);

// table_copy.wast:1010
assert_return(() => call($12, "check_t1", [14]), 5);

// table_copy.wast:1011
assert_return(() => call($12, "check_t1", [15]), 7);

// table_copy.wast:1012
assert_trap(() => call($12, "check_t1", [16]));

// table_copy.wast:1013
assert_trap(() => call($12, "check_t1", [17]));

// table_copy.wast:1014
assert_trap(() => call($12, "check_t1", [18]));

// table_copy.wast:1015
assert_trap(() => call($12, "check_t1", [19]));

// table_copy.wast:1016
assert_trap(() => call($12, "check_t1", [20]));

// table_copy.wast:1017
assert_trap(() => call($12, "check_t1", [21]));

// table_copy.wast:1018
assert_trap(() => call($12, "check_t1", [22]));

// table_copy.wast:1019
assert_trap(() => call($12, "check_t1", [23]));

// table_copy.wast:1020
assert_trap(() => call($12, "check_t1", [24]));

// table_copy.wast:1021
assert_trap(() => call($12, "check_t1", [25]));

// table_copy.wast:1022
assert_trap(() => call($12, "check_t1", [26]));

// table_copy.wast:1023
assert_trap(() => call($12, "check_t1", [27]));

// table_copy.wast:1024
assert_trap(() => call($12, "check_t1", [28]));

// table_copy.wast:1025
assert_trap(() => call($12, "check_t1", [29]));

// table_copy.wast:1027
let $13 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x0f\x41\x02\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1057
run(() => call($13, "test", []));

// table_copy.wast:1058
assert_trap(() => call($13, "check_t0", [0]));

// table_copy.wast:1059
assert_trap(() => call($13, "check_t0", [1]));

// table_copy.wast:1060
assert_return(() => call($13, "check_t0", [2]), 3);

// table_copy.wast:1061
assert_return(() => call($13, "check_t0", [3]), 1);

// table_copy.wast:1062
assert_return(() => call($13, "check_t0", [4]), 4);

// table_copy.wast:1063
assert_return(() => call($13, "check_t0", [5]), 1);

// table_copy.wast:1064
assert_trap(() => call($13, "check_t0", [6]));

// table_copy.wast:1065
assert_trap(() => call($13, "check_t0", [7]));

// table_copy.wast:1066
assert_trap(() => call($13, "check_t0", [8]));

// table_copy.wast:1067
assert_trap(() => call($13, "check_t0", [9]));

// table_copy.wast:1068
assert_trap(() => call($13, "check_t0", [10]));

// table_copy.wast:1069
assert_trap(() => call($13, "check_t0", [11]));

// table_copy.wast:1070
assert_return(() => call($13, "check_t0", [12]), 7);

// table_copy.wast:1071
assert_return(() => call($13, "check_t0", [13]), 5);

// table_copy.wast:1072
assert_return(() => call($13, "check_t0", [14]), 2);

// table_copy.wast:1073
assert_return(() => call($13, "check_t0", [15]), 3);

// table_copy.wast:1074
assert_return(() => call($13, "check_t0", [16]), 6);

// table_copy.wast:1075
assert_trap(() => call($13, "check_t0", [17]));

// table_copy.wast:1076
assert_trap(() => call($13, "check_t0", [18]));

// table_copy.wast:1077
assert_trap(() => call($13, "check_t0", [19]));

// table_copy.wast:1078
assert_trap(() => call($13, "check_t0", [20]));

// table_copy.wast:1079
assert_trap(() => call($13, "check_t0", [21]));

// table_copy.wast:1080
assert_trap(() => call($13, "check_t0", [22]));

// table_copy.wast:1081
assert_trap(() => call($13, "check_t0", [23]));

// table_copy.wast:1082
assert_trap(() => call($13, "check_t0", [24]));

// table_copy.wast:1083
assert_return(() => call($13, "check_t0", [25]), 3);

// table_copy.wast:1084
assert_return(() => call($13, "check_t0", [26]), 6);

// table_copy.wast:1085
assert_trap(() => call($13, "check_t0", [27]));

// table_copy.wast:1086
assert_trap(() => call($13, "check_t0", [28]));

// table_copy.wast:1087
assert_trap(() => call($13, "check_t0", [29]));

// table_copy.wast:1088
assert_trap(() => call($13, "check_t1", [0]));

// table_copy.wast:1089
assert_trap(() => call($13, "check_t1", [1]));

// table_copy.wast:1090
assert_trap(() => call($13, "check_t1", [2]));

// table_copy.wast:1091
assert_return(() => call($13, "check_t1", [3]), 1);

// table_copy.wast:1092
assert_return(() => call($13, "check_t1", [4]), 3);

// table_copy.wast:1093
assert_return(() => call($13, "check_t1", [5]), 1);

// table_copy.wast:1094
assert_return(() => call($13, "check_t1", [6]), 4);

// table_copy.wast:1095
assert_trap(() => call($13, "check_t1", [7]));

// table_copy.wast:1096
assert_trap(() => call($13, "check_t1", [8]));

// table_copy.wast:1097
assert_trap(() => call($13, "check_t1", [9]));

// table_copy.wast:1098
assert_trap(() => call($13, "check_t1", [10]));

// table_copy.wast:1099
assert_return(() => call($13, "check_t1", [11]), 6);

// table_copy.wast:1100
assert_return(() => call($13, "check_t1", [12]), 3);

// table_copy.wast:1101
assert_return(() => call($13, "check_t1", [13]), 2);

// table_copy.wast:1102
assert_return(() => call($13, "check_t1", [14]), 5);

// table_copy.wast:1103
assert_return(() => call($13, "check_t1", [15]), 7);

// table_copy.wast:1104
assert_trap(() => call($13, "check_t1", [16]));

// table_copy.wast:1105
assert_trap(() => call($13, "check_t1", [17]));

// table_copy.wast:1106
assert_trap(() => call($13, "check_t1", [18]));

// table_copy.wast:1107
assert_trap(() => call($13, "check_t1", [19]));

// table_copy.wast:1108
assert_trap(() => call($13, "check_t1", [20]));

// table_copy.wast:1109
assert_trap(() => call($13, "check_t1", [21]));

// table_copy.wast:1110
assert_trap(() => call($13, "check_t1", [22]));

// table_copy.wast:1111
assert_trap(() => call($13, "check_t1", [23]));

// table_copy.wast:1112
assert_trap(() => call($13, "check_t1", [24]));

// table_copy.wast:1113
assert_trap(() => call($13, "check_t1", [25]));

// table_copy.wast:1114
assert_trap(() => call($13, "check_t1", [26]));

// table_copy.wast:1115
assert_trap(() => call($13, "check_t1", [27]));

// table_copy.wast:1116
assert_trap(() => call($13, "check_t1", [28]));

// table_copy.wast:1117
assert_trap(() => call($13, "check_t1", [29]));

// table_copy.wast:1119
let $14 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x19\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1149
run(() => call($14, "test", []));

// table_copy.wast:1150
assert_trap(() => call($14, "check_t0", [0]));

// table_copy.wast:1151
assert_trap(() => call($14, "check_t0", [1]));

// table_copy.wast:1152
assert_return(() => call($14, "check_t0", [2]), 3);

// table_copy.wast:1153
assert_return(() => call($14, "check_t0", [3]), 1);

// table_copy.wast:1154
assert_return(() => call($14, "check_t0", [4]), 4);

// table_copy.wast:1155
assert_return(() => call($14, "check_t0", [5]), 1);

// table_copy.wast:1156
assert_trap(() => call($14, "check_t0", [6]));

// table_copy.wast:1157
assert_trap(() => call($14, "check_t0", [7]));

// table_copy.wast:1158
assert_trap(() => call($14, "check_t0", [8]));

// table_copy.wast:1159
assert_trap(() => call($14, "check_t0", [9]));

// table_copy.wast:1160
assert_trap(() => call($14, "check_t0", [10]));

// table_copy.wast:1161
assert_trap(() => call($14, "check_t0", [11]));

// table_copy.wast:1162
assert_return(() => call($14, "check_t0", [12]), 7);

// table_copy.wast:1163
assert_trap(() => call($14, "check_t0", [13]));

// table_copy.wast:1164
assert_trap(() => call($14, "check_t0", [14]));

// table_copy.wast:1165
assert_trap(() => call($14, "check_t0", [15]));

// table_copy.wast:1166
assert_return(() => call($14, "check_t0", [16]), 6);

// table_copy.wast:1167
assert_trap(() => call($14, "check_t0", [17]));

// table_copy.wast:1168
assert_trap(() => call($14, "check_t0", [18]));

// table_copy.wast:1169
assert_trap(() => call($14, "check_t0", [19]));

// table_copy.wast:1170
assert_trap(() => call($14, "check_t0", [20]));

// table_copy.wast:1171
assert_trap(() => call($14, "check_t0", [21]));

// table_copy.wast:1172
assert_trap(() => call($14, "check_t0", [22]));

// table_copy.wast:1173
assert_trap(() => call($14, "check_t0", [23]));

// table_copy.wast:1174
assert_trap(() => call($14, "check_t0", [24]));

// table_copy.wast:1175
assert_trap(() => call($14, "check_t0", [25]));

// table_copy.wast:1176
assert_trap(() => call($14, "check_t0", [26]));

// table_copy.wast:1177
assert_trap(() => call($14, "check_t0", [27]));

// table_copy.wast:1178
assert_trap(() => call($14, "check_t0", [28]));

// table_copy.wast:1179
assert_trap(() => call($14, "check_t0", [29]));

// table_copy.wast:1180
assert_trap(() => call($14, "check_t1", [0]));

// table_copy.wast:1181
assert_trap(() => call($14, "check_t1", [1]));

// table_copy.wast:1182
assert_trap(() => call($14, "check_t1", [2]));

// table_copy.wast:1183
assert_return(() => call($14, "check_t1", [3]), 1);

// table_copy.wast:1184
assert_return(() => call($14, "check_t1", [4]), 3);

// table_copy.wast:1185
assert_return(() => call($14, "check_t1", [5]), 1);

// table_copy.wast:1186
assert_return(() => call($14, "check_t1", [6]), 4);

// table_copy.wast:1187
assert_trap(() => call($14, "check_t1", [7]));

// table_copy.wast:1188
assert_trap(() => call($14, "check_t1", [8]));

// table_copy.wast:1189
assert_trap(() => call($14, "check_t1", [9]));

// table_copy.wast:1190
assert_trap(() => call($14, "check_t1", [10]));

// table_copy.wast:1191
assert_return(() => call($14, "check_t1", [11]), 6);

// table_copy.wast:1192
assert_return(() => call($14, "check_t1", [12]), 3);

// table_copy.wast:1193
assert_return(() => call($14, "check_t1", [13]), 2);

// table_copy.wast:1194
assert_return(() => call($14, "check_t1", [14]), 5);

// table_copy.wast:1195
assert_return(() => call($14, "check_t1", [15]), 7);

// table_copy.wast:1196
assert_trap(() => call($14, "check_t1", [16]));

// table_copy.wast:1197
assert_trap(() => call($14, "check_t1", [17]));

// table_copy.wast:1198
assert_trap(() => call($14, "check_t1", [18]));

// table_copy.wast:1199
assert_trap(() => call($14, "check_t1", [19]));

// table_copy.wast:1200
assert_trap(() => call($14, "check_t1", [20]));

// table_copy.wast:1201
assert_trap(() => call($14, "check_t1", [21]));

// table_copy.wast:1202
assert_trap(() => call($14, "check_t1", [22]));

// table_copy.wast:1203
assert_trap(() => call($14, "check_t1", [23]));

// table_copy.wast:1204
assert_trap(() => call($14, "check_t1", [24]));

// table_copy.wast:1205
assert_trap(() => call($14, "check_t1", [25]));

// table_copy.wast:1206
assert_trap(() => call($14, "check_t1", [26]));

// table_copy.wast:1207
assert_trap(() => call($14, "check_t1", [27]));

// table_copy.wast:1208
assert_trap(() => call($14, "check_t1", [28]));

// table_copy.wast:1209
assert_trap(() => call($14, "check_t1", [29]));

// table_copy.wast:1211
let $15 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x14\x41\x16\x41\x04\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1241
run(() => call($15, "test", []));

// table_copy.wast:1242
assert_trap(() => call($15, "check_t0", [0]));

// table_copy.wast:1243
assert_trap(() => call($15, "check_t0", [1]));

// table_copy.wast:1244
assert_return(() => call($15, "check_t0", [2]), 3);

// table_copy.wast:1245
assert_return(() => call($15, "check_t0", [3]), 1);

// table_copy.wast:1246
assert_return(() => call($15, "check_t0", [4]), 4);

// table_copy.wast:1247
assert_return(() => call($15, "check_t0", [5]), 1);

// table_copy.wast:1248
assert_trap(() => call($15, "check_t0", [6]));

// table_copy.wast:1249
assert_trap(() => call($15, "check_t0", [7]));

// table_copy.wast:1250
assert_trap(() => call($15, "check_t0", [8]));

// table_copy.wast:1251
assert_trap(() => call($15, "check_t0", [9]));

// table_copy.wast:1252
assert_trap(() => call($15, "check_t0", [10]));

// table_copy.wast:1253
assert_trap(() => call($15, "check_t0", [11]));

// table_copy.wast:1254
assert_return(() => call($15, "check_t0", [12]), 7);

// table_copy.wast:1255
assert_return(() => call($15, "check_t0", [13]), 5);

// table_copy.wast:1256
assert_return(() => call($15, "check_t0", [14]), 2);

// table_copy.wast:1257
assert_return(() => call($15, "check_t0", [15]), 3);

// table_copy.wast:1258
assert_return(() => call($15, "check_t0", [16]), 6);

// table_copy.wast:1259
assert_trap(() => call($15, "check_t0", [17]));

// table_copy.wast:1260
assert_trap(() => call($15, "check_t0", [18]));

// table_copy.wast:1261
assert_trap(() => call($15, "check_t0", [19]));

// table_copy.wast:1262
assert_trap(() => call($15, "check_t0", [20]));

// table_copy.wast:1263
assert_trap(() => call($15, "check_t0", [21]));

// table_copy.wast:1264
assert_trap(() => call($15, "check_t0", [22]));

// table_copy.wast:1265
assert_trap(() => call($15, "check_t0", [23]));

// table_copy.wast:1266
assert_trap(() => call($15, "check_t0", [24]));

// table_copy.wast:1267
assert_trap(() => call($15, "check_t0", [25]));

// table_copy.wast:1268
assert_trap(() => call($15, "check_t0", [26]));

// table_copy.wast:1269
assert_trap(() => call($15, "check_t0", [27]));

// table_copy.wast:1270
assert_trap(() => call($15, "check_t0", [28]));

// table_copy.wast:1271
assert_trap(() => call($15, "check_t0", [29]));

// table_copy.wast:1272
assert_trap(() => call($15, "check_t1", [0]));

// table_copy.wast:1273
assert_trap(() => call($15, "check_t1", [1]));

// table_copy.wast:1274
assert_trap(() => call($15, "check_t1", [2]));

// table_copy.wast:1275
assert_return(() => call($15, "check_t1", [3]), 1);

// table_copy.wast:1276
assert_return(() => call($15, "check_t1", [4]), 3);

// table_copy.wast:1277
assert_return(() => call($15, "check_t1", [5]), 1);

// table_copy.wast:1278
assert_return(() => call($15, "check_t1", [6]), 4);

// table_copy.wast:1279
assert_trap(() => call($15, "check_t1", [7]));

// table_copy.wast:1280
assert_trap(() => call($15, "check_t1", [8]));

// table_copy.wast:1281
assert_trap(() => call($15, "check_t1", [9]));

// table_copy.wast:1282
assert_trap(() => call($15, "check_t1", [10]));

// table_copy.wast:1283
assert_return(() => call($15, "check_t1", [11]), 6);

// table_copy.wast:1284
assert_return(() => call($15, "check_t1", [12]), 3);

// table_copy.wast:1285
assert_return(() => call($15, "check_t1", [13]), 2);

// table_copy.wast:1286
assert_return(() => call($15, "check_t1", [14]), 5);

// table_copy.wast:1287
assert_return(() => call($15, "check_t1", [15]), 7);

// table_copy.wast:1288
assert_trap(() => call($15, "check_t1", [16]));

// table_copy.wast:1289
assert_trap(() => call($15, "check_t1", [17]));

// table_copy.wast:1290
assert_trap(() => call($15, "check_t1", [18]));

// table_copy.wast:1291
assert_trap(() => call($15, "check_t1", [19]));

// table_copy.wast:1292
assert_trap(() => call($15, "check_t1", [20]));

// table_copy.wast:1293
assert_trap(() => call($15, "check_t1", [21]));

// table_copy.wast:1294
assert_trap(() => call($15, "check_t1", [22]));

// table_copy.wast:1295
assert_trap(() => call($15, "check_t1", [23]));

// table_copy.wast:1296
assert_trap(() => call($15, "check_t1", [24]));

// table_copy.wast:1297
assert_trap(() => call($15, "check_t1", [25]));

// table_copy.wast:1298
assert_trap(() => call($15, "check_t1", [26]));

// table_copy.wast:1299
assert_trap(() => call($15, "check_t1", [27]));

// table_copy.wast:1300
assert_trap(() => call($15, "check_t1", [28]));

// table_copy.wast:1301
assert_trap(() => call($15, "check_t1", [29]));

// table_copy.wast:1303
let $16 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x01\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1333
run(() => call($16, "test", []));

// table_copy.wast:1334
assert_trap(() => call($16, "check_t0", [0]));

// table_copy.wast:1335
assert_trap(() => call($16, "check_t0", [1]));

// table_copy.wast:1336
assert_return(() => call($16, "check_t0", [2]), 3);

// table_copy.wast:1337
assert_return(() => call($16, "check_t0", [3]), 1);

// table_copy.wast:1338
assert_return(() => call($16, "check_t0", [4]), 4);

// table_copy.wast:1339
assert_return(() => call($16, "check_t0", [5]), 1);

// table_copy.wast:1340
assert_trap(() => call($16, "check_t0", [6]));

// table_copy.wast:1341
assert_trap(() => call($16, "check_t0", [7]));

// table_copy.wast:1342
assert_trap(() => call($16, "check_t0", [8]));

// table_copy.wast:1343
assert_trap(() => call($16, "check_t0", [9]));

// table_copy.wast:1344
assert_trap(() => call($16, "check_t0", [10]));

// table_copy.wast:1345
assert_trap(() => call($16, "check_t0", [11]));

// table_copy.wast:1346
assert_return(() => call($16, "check_t0", [12]), 7);

// table_copy.wast:1347
assert_return(() => call($16, "check_t0", [13]), 5);

// table_copy.wast:1348
assert_return(() => call($16, "check_t0", [14]), 2);

// table_copy.wast:1349
assert_return(() => call($16, "check_t0", [15]), 3);

// table_copy.wast:1350
assert_return(() => call($16, "check_t0", [16]), 6);

// table_copy.wast:1351
assert_trap(() => call($16, "check_t0", [17]));

// table_copy.wast:1352
assert_trap(() => call($16, "check_t0", [18]));

// table_copy.wast:1353
assert_trap(() => call($16, "check_t0", [19]));

// table_copy.wast:1354
assert_trap(() => call($16, "check_t0", [20]));

// table_copy.wast:1355
assert_trap(() => call($16, "check_t0", [21]));

// table_copy.wast:1356
assert_trap(() => call($16, "check_t0", [22]));

// table_copy.wast:1357
assert_trap(() => call($16, "check_t0", [23]));

// table_copy.wast:1358
assert_trap(() => call($16, "check_t0", [24]));

// table_copy.wast:1359
assert_trap(() => call($16, "check_t0", [25]));

// table_copy.wast:1360
assert_return(() => call($16, "check_t0", [26]), 3);

// table_copy.wast:1361
assert_return(() => call($16, "check_t0", [27]), 1);

// table_copy.wast:1362
assert_trap(() => call($16, "check_t0", [28]));

// table_copy.wast:1363
assert_trap(() => call($16, "check_t0", [29]));

// table_copy.wast:1364
assert_trap(() => call($16, "check_t1", [0]));

// table_copy.wast:1365
assert_trap(() => call($16, "check_t1", [1]));

// table_copy.wast:1366
assert_trap(() => call($16, "check_t1", [2]));

// table_copy.wast:1367
assert_return(() => call($16, "check_t1", [3]), 1);

// table_copy.wast:1368
assert_return(() => call($16, "check_t1", [4]), 3);

// table_copy.wast:1369
assert_return(() => call($16, "check_t1", [5]), 1);

// table_copy.wast:1370
assert_return(() => call($16, "check_t1", [6]), 4);

// table_copy.wast:1371
assert_trap(() => call($16, "check_t1", [7]));

// table_copy.wast:1372
assert_trap(() => call($16, "check_t1", [8]));

// table_copy.wast:1373
assert_trap(() => call($16, "check_t1", [9]));

// table_copy.wast:1374
assert_trap(() => call($16, "check_t1", [10]));

// table_copy.wast:1375
assert_return(() => call($16, "check_t1", [11]), 6);

// table_copy.wast:1376
assert_return(() => call($16, "check_t1", [12]), 3);

// table_copy.wast:1377
assert_return(() => call($16, "check_t1", [13]), 2);

// table_copy.wast:1378
assert_return(() => call($16, "check_t1", [14]), 5);

// table_copy.wast:1379
assert_return(() => call($16, "check_t1", [15]), 7);

// table_copy.wast:1380
assert_trap(() => call($16, "check_t1", [16]));

// table_copy.wast:1381
assert_trap(() => call($16, "check_t1", [17]));

// table_copy.wast:1382
assert_trap(() => call($16, "check_t1", [18]));

// table_copy.wast:1383
assert_trap(() => call($16, "check_t1", [19]));

// table_copy.wast:1384
assert_trap(() => call($16, "check_t1", [20]));

// table_copy.wast:1385
assert_trap(() => call($16, "check_t1", [21]));

// table_copy.wast:1386
assert_trap(() => call($16, "check_t1", [22]));

// table_copy.wast:1387
assert_trap(() => call($16, "check_t1", [23]));

// table_copy.wast:1388
assert_trap(() => call($16, "check_t1", [24]));

// table_copy.wast:1389
assert_trap(() => call($16, "check_t1", [25]));

// table_copy.wast:1390
assert_trap(() => call($16, "check_t1", [26]));

// table_copy.wast:1391
assert_trap(() => call($16, "check_t1", [27]));

// table_copy.wast:1392
assert_trap(() => call($16, "check_t1", [28]));

// table_copy.wast:1393
assert_trap(() => call($16, "check_t1", [29]));

// table_copy.wast:1395
let $17 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x0c\x41\x07\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1425
run(() => call($17, "test", []));

// table_copy.wast:1426
assert_trap(() => call($17, "check_t0", [0]));

// table_copy.wast:1427
assert_trap(() => call($17, "check_t0", [1]));

// table_copy.wast:1428
assert_return(() => call($17, "check_t0", [2]), 3);

// table_copy.wast:1429
assert_return(() => call($17, "check_t0", [3]), 1);

// table_copy.wast:1430
assert_return(() => call($17, "check_t0", [4]), 4);

// table_copy.wast:1431
assert_return(() => call($17, "check_t0", [5]), 1);

// table_copy.wast:1432
assert_trap(() => call($17, "check_t0", [6]));

// table_copy.wast:1433
assert_trap(() => call($17, "check_t0", [7]));

// table_copy.wast:1434
assert_trap(() => call($17, "check_t0", [8]));

// table_copy.wast:1435
assert_trap(() => call($17, "check_t0", [9]));

// table_copy.wast:1436
assert_return(() => call($17, "check_t0", [10]), 7);

// table_copy.wast:1437
assert_return(() => call($17, "check_t0", [11]), 5);

// table_copy.wast:1438
assert_return(() => call($17, "check_t0", [12]), 2);

// table_copy.wast:1439
assert_return(() => call($17, "check_t0", [13]), 3);

// table_copy.wast:1440
assert_return(() => call($17, "check_t0", [14]), 6);

// table_copy.wast:1441
assert_trap(() => call($17, "check_t0", [15]));

// table_copy.wast:1442
assert_trap(() => call($17, "check_t0", [16]));

// table_copy.wast:1443
assert_trap(() => call($17, "check_t0", [17]));

// table_copy.wast:1444
assert_trap(() => call($17, "check_t0", [18]));

// table_copy.wast:1445
assert_trap(() => call($17, "check_t0", [19]));

// table_copy.wast:1446
assert_trap(() => call($17, "check_t0", [20]));

// table_copy.wast:1447
assert_trap(() => call($17, "check_t0", [21]));

// table_copy.wast:1448
assert_trap(() => call($17, "check_t0", [22]));

// table_copy.wast:1449
assert_trap(() => call($17, "check_t0", [23]));

// table_copy.wast:1450
assert_trap(() => call($17, "check_t0", [24]));

// table_copy.wast:1451
assert_trap(() => call($17, "check_t0", [25]));

// table_copy.wast:1452
assert_trap(() => call($17, "check_t0", [26]));

// table_copy.wast:1453
assert_trap(() => call($17, "check_t0", [27]));

// table_copy.wast:1454
assert_trap(() => call($17, "check_t0", [28]));

// table_copy.wast:1455
assert_trap(() => call($17, "check_t0", [29]));

// table_copy.wast:1456
assert_trap(() => call($17, "check_t1", [0]));

// table_copy.wast:1457
assert_trap(() => call($17, "check_t1", [1]));

// table_copy.wast:1458
assert_trap(() => call($17, "check_t1", [2]));

// table_copy.wast:1459
assert_return(() => call($17, "check_t1", [3]), 1);

// table_copy.wast:1460
assert_return(() => call($17, "check_t1", [4]), 3);

// table_copy.wast:1461
assert_return(() => call($17, "check_t1", [5]), 1);

// table_copy.wast:1462
assert_return(() => call($17, "check_t1", [6]), 4);

// table_copy.wast:1463
assert_trap(() => call($17, "check_t1", [7]));

// table_copy.wast:1464
assert_trap(() => call($17, "check_t1", [8]));

// table_copy.wast:1465
assert_trap(() => call($17, "check_t1", [9]));

// table_copy.wast:1466
assert_trap(() => call($17, "check_t1", [10]));

// table_copy.wast:1467
assert_return(() => call($17, "check_t1", [11]), 6);

// table_copy.wast:1468
assert_return(() => call($17, "check_t1", [12]), 3);

// table_copy.wast:1469
assert_return(() => call($17, "check_t1", [13]), 2);

// table_copy.wast:1470
assert_return(() => call($17, "check_t1", [14]), 5);

// table_copy.wast:1471
assert_return(() => call($17, "check_t1", [15]), 7);

// table_copy.wast:1472
assert_trap(() => call($17, "check_t1", [16]));

// table_copy.wast:1473
assert_trap(() => call($17, "check_t1", [17]));

// table_copy.wast:1474
assert_trap(() => call($17, "check_t1", [18]));

// table_copy.wast:1475
assert_trap(() => call($17, "check_t1", [19]));

// table_copy.wast:1476
assert_trap(() => call($17, "check_t1", [20]));

// table_copy.wast:1477
assert_trap(() => call($17, "check_t1", [21]));

// table_copy.wast:1478
assert_trap(() => call($17, "check_t1", [22]));

// table_copy.wast:1479
assert_trap(() => call($17, "check_t1", [23]));

// table_copy.wast:1480
assert_trap(() => call($17, "check_t1", [24]));

// table_copy.wast:1481
assert_trap(() => call($17, "check_t1", [25]));

// table_copy.wast:1482
assert_trap(() => call($17, "check_t1", [26]));

// table_copy.wast:1483
assert_trap(() => call($17, "check_t1", [27]));

// table_copy.wast:1484
assert_trap(() => call($17, "check_t1", [28]));

// table_copy.wast:1485
assert_trap(() => call($17, "check_t1", [29]));

// table_copy.wast:1487
let $18 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x0a\x41\x07\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1517
run(() => call($18, "test", []));

// table_copy.wast:1518
assert_trap(() => call($18, "check_t0", [0]));

// table_copy.wast:1519
assert_trap(() => call($18, "check_t0", [1]));

// table_copy.wast:1520
assert_return(() => call($18, "check_t0", [2]), 3);

// table_copy.wast:1521
assert_return(() => call($18, "check_t0", [3]), 1);

// table_copy.wast:1522
assert_return(() => call($18, "check_t0", [4]), 4);

// table_copy.wast:1523
assert_return(() => call($18, "check_t0", [5]), 1);

// table_copy.wast:1524
assert_trap(() => call($18, "check_t0", [6]));

// table_copy.wast:1525
assert_trap(() => call($18, "check_t0", [7]));

// table_copy.wast:1526
assert_trap(() => call($18, "check_t0", [8]));

// table_copy.wast:1527
assert_trap(() => call($18, "check_t0", [9]));

// table_copy.wast:1528
assert_trap(() => call($18, "check_t0", [10]));

// table_copy.wast:1529
assert_trap(() => call($18, "check_t0", [11]));

// table_copy.wast:1530
assert_trap(() => call($18, "check_t0", [12]));

// table_copy.wast:1531
assert_trap(() => call($18, "check_t0", [13]));

// table_copy.wast:1532
assert_return(() => call($18, "check_t0", [14]), 7);

// table_copy.wast:1533
assert_return(() => call($18, "check_t0", [15]), 5);

// table_copy.wast:1534
assert_return(() => call($18, "check_t0", [16]), 2);

// table_copy.wast:1535
assert_return(() => call($18, "check_t0", [17]), 3);

// table_copy.wast:1536
assert_return(() => call($18, "check_t0", [18]), 6);

// table_copy.wast:1537
assert_trap(() => call($18, "check_t0", [19]));

// table_copy.wast:1538
assert_trap(() => call($18, "check_t0", [20]));

// table_copy.wast:1539
assert_trap(() => call($18, "check_t0", [21]));

// table_copy.wast:1540
assert_trap(() => call($18, "check_t0", [22]));

// table_copy.wast:1541
assert_trap(() => call($18, "check_t0", [23]));

// table_copy.wast:1542
assert_trap(() => call($18, "check_t0", [24]));

// table_copy.wast:1543
assert_trap(() => call($18, "check_t0", [25]));

// table_copy.wast:1544
assert_trap(() => call($18, "check_t0", [26]));

// table_copy.wast:1545
assert_trap(() => call($18, "check_t0", [27]));

// table_copy.wast:1546
assert_trap(() => call($18, "check_t0", [28]));

// table_copy.wast:1547
assert_trap(() => call($18, "check_t0", [29]));

// table_copy.wast:1548
assert_trap(() => call($18, "check_t1", [0]));

// table_copy.wast:1549
assert_trap(() => call($18, "check_t1", [1]));

// table_copy.wast:1550
assert_trap(() => call($18, "check_t1", [2]));

// table_copy.wast:1551
assert_return(() => call($18, "check_t1", [3]), 1);

// table_copy.wast:1552
assert_return(() => call($18, "check_t1", [4]), 3);

// table_copy.wast:1553
assert_return(() => call($18, "check_t1", [5]), 1);

// table_copy.wast:1554
assert_return(() => call($18, "check_t1", [6]), 4);

// table_copy.wast:1555
assert_trap(() => call($18, "check_t1", [7]));

// table_copy.wast:1556
assert_trap(() => call($18, "check_t1", [8]));

// table_copy.wast:1557
assert_trap(() => call($18, "check_t1", [9]));

// table_copy.wast:1558
assert_trap(() => call($18, "check_t1", [10]));

// table_copy.wast:1559
assert_return(() => call($18, "check_t1", [11]), 6);

// table_copy.wast:1560
assert_return(() => call($18, "check_t1", [12]), 3);

// table_copy.wast:1561
assert_return(() => call($18, "check_t1", [13]), 2);

// table_copy.wast:1562
assert_return(() => call($18, "check_t1", [14]), 5);

// table_copy.wast:1563
assert_return(() => call($18, "check_t1", [15]), 7);

// table_copy.wast:1564
assert_trap(() => call($18, "check_t1", [16]));

// table_copy.wast:1565
assert_trap(() => call($18, "check_t1", [17]));

// table_copy.wast:1566
assert_trap(() => call($18, "check_t1", [18]));

// table_copy.wast:1567
assert_trap(() => call($18, "check_t1", [19]));

// table_copy.wast:1568
assert_trap(() => call($18, "check_t1", [20]));

// table_copy.wast:1569
assert_trap(() => call($18, "check_t1", [21]));

// table_copy.wast:1570
assert_trap(() => call($18, "check_t1", [22]));

// table_copy.wast:1571
assert_trap(() => call($18, "check_t1", [23]));

// table_copy.wast:1572
assert_trap(() => call($18, "check_t1", [24]));

// table_copy.wast:1573
assert_trap(() => call($18, "check_t1", [25]));

// table_copy.wast:1574
assert_trap(() => call($18, "check_t1", [26]));

// table_copy.wast:1575
assert_trap(() => call($18, "check_t1", [27]));

// table_copy.wast:1576
assert_trap(() => call($18, "check_t1", [28]));

// table_copy.wast:1577
assert_trap(() => call($18, "check_t1", [29]));

// table_copy.wast:1579
let $19 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x00\x41\x14\xfc\x0e\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1609
run(() => call($19, "test", []));

// table_copy.wast:1610
assert_trap(() => call($19, "check_t0", [0]));

// table_copy.wast:1611
assert_trap(() => call($19, "check_t0", [1]));

// table_copy.wast:1612
assert_return(() => call($19, "check_t0", [2]), 3);

// table_copy.wast:1613
assert_return(() => call($19, "check_t0", [3]), 1);

// table_copy.wast:1614
assert_return(() => call($19, "check_t0", [4]), 4);

// table_copy.wast:1615
assert_return(() => call($19, "check_t0", [5]), 1);

// table_copy.wast:1616
assert_trap(() => call($19, "check_t0", [6]));

// table_copy.wast:1617
assert_trap(() => call($19, "check_t0", [7]));

// table_copy.wast:1618
assert_trap(() => call($19, "check_t0", [8]));

// table_copy.wast:1619
assert_trap(() => call($19, "check_t0", [9]));

// table_copy.wast:1620
assert_trap(() => call($19, "check_t0", [10]));

// table_copy.wast:1621
assert_trap(() => call($19, "check_t0", [11]));

// table_copy.wast:1622
assert_return(() => call($19, "check_t0", [12]), 7);

// table_copy.wast:1623
assert_return(() => call($19, "check_t0", [13]), 5);

// table_copy.wast:1624
assert_return(() => call($19, "check_t0", [14]), 2);

// table_copy.wast:1625
assert_return(() => call($19, "check_t0", [15]), 3);

// table_copy.wast:1626
assert_return(() => call($19, "check_t0", [16]), 6);

// table_copy.wast:1627
assert_trap(() => call($19, "check_t0", [17]));

// table_copy.wast:1628
assert_trap(() => call($19, "check_t0", [18]));

// table_copy.wast:1629
assert_trap(() => call($19, "check_t0", [19]));

// table_copy.wast:1630
assert_trap(() => call($19, "check_t0", [20]));

// table_copy.wast:1631
assert_trap(() => call($19, "check_t0", [21]));

// table_copy.wast:1632
assert_trap(() => call($19, "check_t0", [22]));

// table_copy.wast:1633
assert_trap(() => call($19, "check_t0", [23]));

// table_copy.wast:1634
assert_trap(() => call($19, "check_t0", [24]));

// table_copy.wast:1635
assert_trap(() => call($19, "check_t0", [25]));

// table_copy.wast:1636
assert_trap(() => call($19, "check_t0", [26]));

// table_copy.wast:1637
assert_trap(() => call($19, "check_t0", [27]));

// table_copy.wast:1638
assert_trap(() => call($19, "check_t0", [28]));

// table_copy.wast:1639
assert_trap(() => call($19, "check_t0", [29]));

// table_copy.wast:1640
assert_trap(() => call($19, "check_t1", [0]));

// table_copy.wast:1641
assert_trap(() => call($19, "check_t1", [1]));

// table_copy.wast:1642
assert_trap(() => call($19, "check_t1", [2]));

// table_copy.wast:1643
assert_return(() => call($19, "check_t1", [3]), 1);

// table_copy.wast:1644
assert_return(() => call($19, "check_t1", [4]), 3);

// table_copy.wast:1645
assert_return(() => call($19, "check_t1", [5]), 1);

// table_copy.wast:1646
assert_return(() => call($19, "check_t1", [6]), 4);

// table_copy.wast:1647
assert_trap(() => call($19, "check_t1", [7]));

// table_copy.wast:1648
assert_trap(() => call($19, "check_t1", [8]));

// table_copy.wast:1649
assert_trap(() => call($19, "check_t1", [9]));

// table_copy.wast:1650
assert_trap(() => call($19, "check_t1", [10]));

// table_copy.wast:1651
assert_trap(() => call($19, "check_t1", [11]));

// table_copy.wast:1652
assert_return(() => call($19, "check_t1", [12]), 3);

// table_copy.wast:1653
assert_return(() => call($19, "check_t1", [13]), 1);

// table_copy.wast:1654
assert_return(() => call($19, "check_t1", [14]), 4);

// table_copy.wast:1655
assert_return(() => call($19, "check_t1", [15]), 1);

// table_copy.wast:1656
assert_trap(() => call($19, "check_t1", [16]));

// table_copy.wast:1657
assert_trap(() => call($19, "check_t1", [17]));

// table_copy.wast:1658
assert_trap(() => call($19, "check_t1", [18]));

// table_copy.wast:1659
assert_trap(() => call($19, "check_t1", [19]));

// table_copy.wast:1660
assert_trap(() => call($19, "check_t1", [20]));

// table_copy.wast:1661
assert_trap(() => call($19, "check_t1", [21]));

// table_copy.wast:1662
assert_return(() => call($19, "check_t1", [22]), 7);

// table_copy.wast:1663
assert_return(() => call($19, "check_t1", [23]), 5);

// table_copy.wast:1664
assert_return(() => call($19, "check_t1", [24]), 2);

// table_copy.wast:1665
assert_return(() => call($19, "check_t1", [25]), 3);

// table_copy.wast:1666
assert_return(() => call($19, "check_t1", [26]), 6);

// table_copy.wast:1667
assert_trap(() => call($19, "check_t1", [27]));

// table_copy.wast:1668
assert_trap(() => call($19, "check_t1", [28]));

// table_copy.wast:1669
assert_trap(() => call($19, "check_t1", [29]));

// table_copy.wast:1671
let $20 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x01\x41\x03\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1694
assert_trap(() => call($20, "test", []));

// table_copy.wast:1696
let $21 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x7e\x41\x01\x41\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1719
assert_trap(() => call($21, "test", []));

// table_copy.wast:1721
let $22 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x06\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1744
assert_trap(() => call($22, "test", []));

// table_copy.wast:1746
let $23 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x7e\x41\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1769
assert_trap(() => call($23, "test", []));

// table_copy.wast:1771
let $24 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1794
run(() => call($24, "test", []));

// table_copy.wast:1796
let $25 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x0f\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1819
run(() => call($25, "test", []));

// table_copy.wast:1821
let $26 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x0f\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1844
assert_trap(() => call($26, "test", []));

// table_copy.wast:1846
let $27 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1e\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1869
run(() => call($27, "test", []));

// table_copy.wast:1871
let $28 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1f\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1894
assert_trap(() => call($28, "test", []));

// table_copy.wast:1896
let $29 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x1e\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1919
run(() => call($29, "test", []));

// table_copy.wast:1921
let $30 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x1f\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1944
assert_trap(() => call($30, "test", []));

// table_copy.wast:1946
let $31 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x01\x41\x03\xfc\x0e\x01\x00\x0b");

// table_copy.wast:1969
assert_trap(() => call($31, "test", []));

// table_copy.wast:1971
let $32 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x7e\x41\x01\x41\x02\xfc\x0e\x01\x00\x0b");

// table_copy.wast:1994
assert_trap(() => call($32, "test", []));

// table_copy.wast:1996
let $33 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x06\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2019
assert_trap(() => call($33, "test", []));

// table_copy.wast:2021
let $34 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x7e\x41\x02\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2044
assert_trap(() => call($34, "test", []));

// table_copy.wast:2046
let $35 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2069
run(() => call($35, "test", []));

// table_copy.wast:2071
let $36 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x0f\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2094
run(() => call($36, "test", []));

// table_copy.wast:2096
let $37 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x0f\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2119
assert_trap(() => call($37, "test", []));

// table_copy.wast:2121
let $38 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1e\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2144
run(() => call($38, "test", []));

// table_copy.wast:2146
let $39 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1f\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2169
assert_trap(() => call($39, "test", []));

// table_copy.wast:2171
let $40 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x1e\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2194
run(() => call($40, "test", []));

// table_copy.wast:2196
let $41 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x1f\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2219
assert_trap(() => call($41, "test", []));

// table_copy.wast:2221
let $42 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2247
assert_trap(() => call($42, "run", [24, 0, 16]));

// table_copy.wast:2249
assert_return(() => call($42, "test", [0]), 0);

// table_copy.wast:2250
assert_return(() => call($42, "test", [1]), 1);

// table_copy.wast:2251
assert_return(() => call($42, "test", [2]), 2);

// table_copy.wast:2252
assert_return(() => call($42, "test", [3]), 3);

// table_copy.wast:2253
assert_return(() => call($42, "test", [4]), 4);

// table_copy.wast:2254
assert_return(() => call($42, "test", [5]), 5);

// table_copy.wast:2255
assert_return(() => call($42, "test", [6]), 6);

// table_copy.wast:2256
assert_return(() => call($42, "test", [7]), 7);

// table_copy.wast:2257
assert_trap(() => call($42, "test", [8]));

// table_copy.wast:2258
assert_trap(() => call($42, "test", [9]));

// table_copy.wast:2259
assert_trap(() => call($42, "test", [10]));

// table_copy.wast:2260
assert_trap(() => call($42, "test", [11]));

// table_copy.wast:2261
assert_trap(() => call($42, "test", [12]));

// table_copy.wast:2262
assert_trap(() => call($42, "test", [13]));

// table_copy.wast:2263
assert_trap(() => call($42, "test", [14]));

// table_copy.wast:2264
assert_trap(() => call($42, "test", [15]));

// table_copy.wast:2265
assert_trap(() => call($42, "test", [16]));

// table_copy.wast:2266
assert_trap(() => call($42, "test", [17]));

// table_copy.wast:2267
assert_trap(() => call($42, "test", [18]));

// table_copy.wast:2268
assert_trap(() => call($42, "test", [19]));

// table_copy.wast:2269
assert_trap(() => call($42, "test", [20]));

// table_copy.wast:2270
assert_trap(() => call($42, "test", [21]));

// table_copy.wast:2271
assert_trap(() => call($42, "test", [22]));

// table_copy.wast:2272
assert_trap(() => call($42, "test", [23]));

// table_copy.wast:2273
assert_trap(() => call($42, "test", [24]));

// table_copy.wast:2274
assert_trap(() => call($42, "test", [25]));

// table_copy.wast:2275
assert_trap(() => call($42, "test", [26]));

// table_copy.wast:2276
assert_trap(() => call($42, "test", [27]));

// table_copy.wast:2277
assert_trap(() => call($42, "test", [28]));

// table_copy.wast:2278
assert_trap(() => call($42, "test", [29]));

// table_copy.wast:2279
assert_trap(() => call($42, "test", [30]));

// table_copy.wast:2280
assert_trap(() => call($42, "test", [31]));

// table_copy.wast:2282
let $43 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8f\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x09\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2308
assert_trap(() => call($43, "run", [23, 0, 15]));

// table_copy.wast:2310
assert_return(() => call($43, "test", [0]), 0);

// table_copy.wast:2311
assert_return(() => call($43, "test", [1]), 1);

// table_copy.wast:2312
assert_return(() => call($43, "test", [2]), 2);

// table_copy.wast:2313
assert_return(() => call($43, "test", [3]), 3);

// table_copy.wast:2314
assert_return(() => call($43, "test", [4]), 4);

// table_copy.wast:2315
assert_return(() => call($43, "test", [5]), 5);

// table_copy.wast:2316
assert_return(() => call($43, "test", [6]), 6);

// table_copy.wast:2317
assert_return(() => call($43, "test", [7]), 7);

// table_copy.wast:2318
assert_return(() => call($43, "test", [8]), 8);

// table_copy.wast:2319
assert_trap(() => call($43, "test", [9]));

// table_copy.wast:2320
assert_trap(() => call($43, "test", [10]));

// table_copy.wast:2321
assert_trap(() => call($43, "test", [11]));

// table_copy.wast:2322
assert_trap(() => call($43, "test", [12]));

// table_copy.wast:2323
assert_trap(() => call($43, "test", [13]));

// table_copy.wast:2324
assert_trap(() => call($43, "test", [14]));

// table_copy.wast:2325
assert_trap(() => call($43, "test", [15]));

// table_copy.wast:2326
assert_trap(() => call($43, "test", [16]));

// table_copy.wast:2327
assert_trap(() => call($43, "test", [17]));

// table_copy.wast:2328
assert_trap(() => call($43, "test", [18]));

// table_copy.wast:2329
assert_trap(() => call($43, "test", [19]));

// table_copy.wast:2330
assert_trap(() => call($43, "test", [20]));

// table_copy.wast:2331
assert_trap(() => call($43, "test", [21]));

// table_copy.wast:2332
assert_trap(() => call($43, "test", [22]));

// table_copy.wast:2333
assert_trap(() => call($43, "test", [23]));

// table_copy.wast:2334
assert_trap(() => call($43, "test", [24]));

// table_copy.wast:2335
assert_trap(() => call($43, "test", [25]));

// table_copy.wast:2336
assert_trap(() => call($43, "test", [26]));

// table_copy.wast:2337
assert_trap(() => call($43, "test", [27]));

// table_copy.wast:2338
assert_trap(() => call($43, "test", [28]));

// table_copy.wast:2339
assert_trap(() => call($43, "test", [29]));

// table_copy.wast:2340
assert_trap(() => call($43, "test", [30]));

// table_copy.wast:2341
assert_trap(() => call($43, "test", [31]));

// table_copy.wast:2343
let $44 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2369
assert_trap(() => call($44, "run", [0, 24, 16]));

// table_copy.wast:2371
assert_trap(() => call($44, "test", [0]));

// table_copy.wast:2372
assert_trap(() => call($44, "test", [1]));

// table_copy.wast:2373
assert_trap(() => call($44, "test", [2]));

// table_copy.wast:2374
assert_trap(() => call($44, "test", [3]));

// table_copy.wast:2375
assert_trap(() => call($44, "test", [4]));

// table_copy.wast:2376
assert_trap(() => call($44, "test", [5]));

// table_copy.wast:2377
assert_trap(() => call($44, "test", [6]));

// table_copy.wast:2378
assert_trap(() => call($44, "test", [7]));

// table_copy.wast:2379
assert_trap(() => call($44, "test", [8]));

// table_copy.wast:2380
assert_trap(() => call($44, "test", [9]));

// table_copy.wast:2381
assert_trap(() => call($44, "test", [10]));

// table_copy.wast:2382
assert_trap(() => call($44, "test", [11]));

// table_copy.wast:2383
assert_trap(() => call($44, "test", [12]));

// table_copy.wast:2384
assert_trap(() => call($44, "test", [13]));

// table_copy.wast:2385
assert_trap(() => call($44, "test", [14]));

// table_copy.wast:2386
assert_trap(() => call($44, "test", [15]));

// table_copy.wast:2387
assert_trap(() => call($44, "test", [16]));

// table_copy.wast:2388
assert_trap(() => call($44, "test", [17]));

// table_copy.wast:2389
assert_trap(() => call($44, "test", [18]));

// table_copy.wast:2390
assert_trap(() => call($44, "test", [19]));

// table_copy.wast:2391
assert_trap(() => call($44, "test", [20]));

// table_copy.wast:2392
assert_trap(() => call($44, "test", [21]));

// table_copy.wast:2393
assert_trap(() => call($44, "test", [22]));

// table_copy.wast:2394
assert_trap(() => call($44, "test", [23]));

// table_copy.wast:2395
assert_return(() => call($44, "test", [24]), 0);

// table_copy.wast:2396
assert_return(() => call($44, "test", [25]), 1);

// table_copy.wast:2397
assert_return(() => call($44, "test", [26]), 2);

// table_copy.wast:2398
assert_return(() => call($44, "test", [27]), 3);

// table_copy.wast:2399
assert_return(() => call($44, "test", [28]), 4);

// table_copy.wast:2400
assert_return(() => call($44, "test", [29]), 5);

// table_copy.wast:2401
assert_return(() => call($44, "test", [30]), 6);

// table_copy.wast:2402
assert_return(() => call($44, "test", [31]), 7);

// table_copy.wast:2404
let $45 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8f\x80\x80\x80\x00\x01\x00\x41\x17\x0b\x09\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2430
assert_trap(() => call($45, "run", [0, 23, 15]));

// table_copy.wast:2432
assert_trap(() => call($45, "test", [0]));

// table_copy.wast:2433
assert_trap(() => call($45, "test", [1]));

// table_copy.wast:2434
assert_trap(() => call($45, "test", [2]));

// table_copy.wast:2435
assert_trap(() => call($45, "test", [3]));

// table_copy.wast:2436
assert_trap(() => call($45, "test", [4]));

// table_copy.wast:2437
assert_trap(() => call($45, "test", [5]));

// table_copy.wast:2438
assert_trap(() => call($45, "test", [6]));

// table_copy.wast:2439
assert_trap(() => call($45, "test", [7]));

// table_copy.wast:2440
assert_trap(() => call($45, "test", [8]));

// table_copy.wast:2441
assert_trap(() => call($45, "test", [9]));

// table_copy.wast:2442
assert_trap(() => call($45, "test", [10]));

// table_copy.wast:2443
assert_trap(() => call($45, "test", [11]));

// table_copy.wast:2444
assert_trap(() => call($45, "test", [12]));

// table_copy.wast:2445
assert_trap(() => call($45, "test", [13]));

// table_copy.wast:2446
assert_trap(() => call($45, "test", [14]));

// table_copy.wast:2447
assert_trap(() => call($45, "test", [15]));

// table_copy.wast:2448
assert_trap(() => call($45, "test", [16]));

// table_copy.wast:2449
assert_trap(() => call($45, "test", [17]));

// table_copy.wast:2450
assert_trap(() => call($45, "test", [18]));

// table_copy.wast:2451
assert_trap(() => call($45, "test", [19]));

// table_copy.wast:2452
assert_trap(() => call($45, "test", [20]));

// table_copy.wast:2453
assert_trap(() => call($45, "test", [21]));

// table_copy.wast:2454
assert_trap(() => call($45, "test", [22]));

// table_copy.wast:2455
assert_return(() => call($45, "test", [23]), 0);

// table_copy.wast:2456
assert_return(() => call($45, "test", [24]), 1);

// table_copy.wast:2457
assert_return(() => call($45, "test", [25]), 2);

// table_copy.wast:2458
assert_return(() => call($45, "test", [26]), 3);

// table_copy.wast:2459
assert_return(() => call($45, "test", [27]), 4);

// table_copy.wast:2460
assert_return(() => call($45, "test", [28]), 5);

// table_copy.wast:2461
assert_return(() => call($45, "test", [29]), 6);

// table_copy.wast:2462
assert_return(() => call($45, "test", [30]), 7);

// table_copy.wast:2463
assert_return(() => call($45, "test", [31]), 8);

// table_copy.wast:2465
let $46 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x0b\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2491
assert_trap(() => call($46, "run", [24, 11, 16]));

// table_copy.wast:2493
assert_trap(() => call($46, "test", [0]));

// table_copy.wast:2494
assert_trap(() => call($46, "test", [1]));

// table_copy.wast:2495
assert_trap(() => call($46, "test", [2]));

// table_copy.wast:2496
assert_trap(() => call($46, "test", [3]));

// table_copy.wast:2497
assert_trap(() => call($46, "test", [4]));

// table_copy.wast:2498
assert_trap(() => call($46, "test", [5]));

// table_copy.wast:2499
assert_trap(() => call($46, "test", [6]));

// table_copy.wast:2500
assert_trap(() => call($46, "test", [7]));

// table_copy.wast:2501
assert_trap(() => call($46, "test", [8]));

// table_copy.wast:2502
assert_trap(() => call($46, "test", [9]));

// table_copy.wast:2503
assert_trap(() => call($46, "test", [10]));

// table_copy.wast:2504
assert_return(() => call($46, "test", [11]), 0);

// table_copy.wast:2505
assert_return(() => call($46, "test", [12]), 1);

// table_copy.wast:2506
assert_return(() => call($46, "test", [13]), 2);

// table_copy.wast:2507
assert_return(() => call($46, "test", [14]), 3);

// table_copy.wast:2508
assert_return(() => call($46, "test", [15]), 4);

// table_copy.wast:2509
assert_return(() => call($46, "test", [16]), 5);

// table_copy.wast:2510
assert_return(() => call($46, "test", [17]), 6);

// table_copy.wast:2511
assert_return(() => call($46, "test", [18]), 7);

// table_copy.wast:2512
assert_trap(() => call($46, "test", [19]));

// table_copy.wast:2513
assert_trap(() => call($46, "test", [20]));

// table_copy.wast:2514
assert_trap(() => call($46, "test", [21]));

// table_copy.wast:2515
assert_trap(() => call($46, "test", [22]));

// table_copy.wast:2516
assert_trap(() => call($46, "test", [23]));

// table_copy.wast:2517
assert_trap(() => call($46, "test", [24]));

// table_copy.wast:2518
assert_trap(() => call($46, "test", [25]));

// table_copy.wast:2519
assert_trap(() => call($46, "test", [26]));

// table_copy.wast:2520
assert_trap(() => call($46, "test", [27]));

// table_copy.wast:2521
assert_trap(() => call($46, "test", [28]));

// table_copy.wast:2522
assert_trap(() => call($46, "test", [29]));

// table_copy.wast:2523
assert_trap(() => call($46, "test", [30]));

// table_copy.wast:2524
assert_trap(() => call($46, "test", [31]));

// table_copy.wast:2526
let $47 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2552
assert_trap(() => call($47, "run", [11, 24, 16]));

// table_copy.wast:2554
assert_trap(() => call($47, "test", [0]));

// table_copy.wast:2555
assert_trap(() => call($47, "test", [1]));

// table_copy.wast:2556
assert_trap(() => call($47, "test", [2]));

// table_copy.wast:2557
assert_trap(() => call($47, "test", [3]));

// table_copy.wast:2558
assert_trap(() => call($47, "test", [4]));

// table_copy.wast:2559
assert_trap(() => call($47, "test", [5]));

// table_copy.wast:2560
assert_trap(() => call($47, "test", [6]));

// table_copy.wast:2561
assert_trap(() => call($47, "test", [7]));

// table_copy.wast:2562
assert_trap(() => call($47, "test", [8]));

// table_copy.wast:2563
assert_trap(() => call($47, "test", [9]));

// table_copy.wast:2564
assert_trap(() => call($47, "test", [10]));

// table_copy.wast:2565
assert_trap(() => call($47, "test", [11]));

// table_copy.wast:2566
assert_trap(() => call($47, "test", [12]));

// table_copy.wast:2567
assert_trap(() => call($47, "test", [13]));

// table_copy.wast:2568
assert_trap(() => call($47, "test", [14]));

// table_copy.wast:2569
assert_trap(() => call($47, "test", [15]));

// table_copy.wast:2570
assert_trap(() => call($47, "test", [16]));

// table_copy.wast:2571
assert_trap(() => call($47, "test", [17]));

// table_copy.wast:2572
assert_trap(() => call($47, "test", [18]));

// table_copy.wast:2573
assert_trap(() => call($47, "test", [19]));

// table_copy.wast:2574
assert_trap(() => call($47, "test", [20]));

// table_copy.wast:2575
assert_trap(() => call($47, "test", [21]));

// table_copy.wast:2576
assert_trap(() => call($47, "test", [22]));

// table_copy.wast:2577
assert_trap(() => call($47, "test", [23]));

// table_copy.wast:2578
assert_return(() => call($47, "test", [24]), 0);

// table_copy.wast:2579
assert_return(() => call($47, "test", [25]), 1);

// table_copy.wast:2580
assert_return(() => call($47, "test", [26]), 2);

// table_copy.wast:2581
assert_return(() => call($47, "test", [27]), 3);

// table_copy.wast:2582
assert_return(() => call($47, "test", [28]), 4);

// table_copy.wast:2583
assert_return(() => call($47, "test", [29]), 5);

// table_copy.wast:2584
assert_return(() => call($47, "test", [30]), 6);

// table_copy.wast:2585
assert_return(() => call($47, "test", [31]), 7);

// table_copy.wast:2587
let $48 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x15\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2613
assert_trap(() => call($48, "run", [24, 21, 16]));

// table_copy.wast:2615
assert_trap(() => call($48, "test", [0]));

// table_copy.wast:2616
assert_trap(() => call($48, "test", [1]));

// table_copy.wast:2617
assert_trap(() => call($48, "test", [2]));

// table_copy.wast:2618
assert_trap(() => call($48, "test", [3]));

// table_copy.wast:2619
assert_trap(() => call($48, "test", [4]));

// table_copy.wast:2620
assert_trap(() => call($48, "test", [5]));

// table_copy.wast:2621
assert_trap(() => call($48, "test", [6]));

// table_copy.wast:2622
assert_trap(() => call($48, "test", [7]));

// table_copy.wast:2623
assert_trap(() => call($48, "test", [8]));

// table_copy.wast:2624
assert_trap(() => call($48, "test", [9]));

// table_copy.wast:2625
assert_trap(() => call($48, "test", [10]));

// table_copy.wast:2626
assert_trap(() => call($48, "test", [11]));

// table_copy.wast:2627
assert_trap(() => call($48, "test", [12]));

// table_copy.wast:2628
assert_trap(() => call($48, "test", [13]));

// table_copy.wast:2629
assert_trap(() => call($48, "test", [14]));

// table_copy.wast:2630
assert_trap(() => call($48, "test", [15]));

// table_copy.wast:2631
assert_trap(() => call($48, "test", [16]));

// table_copy.wast:2632
assert_trap(() => call($48, "test", [17]));

// table_copy.wast:2633
assert_trap(() => call($48, "test", [18]));

// table_copy.wast:2634
assert_trap(() => call($48, "test", [19]));

// table_copy.wast:2635
assert_trap(() => call($48, "test", [20]));

// table_copy.wast:2636
assert_return(() => call($48, "test", [21]), 0);

// table_copy.wast:2637
assert_return(() => call($48, "test", [22]), 1);

// table_copy.wast:2638
assert_return(() => call($48, "test", [23]), 2);

// table_copy.wast:2639
assert_return(() => call($48, "test", [24]), 3);

// table_copy.wast:2640
assert_return(() => call($48, "test", [25]), 4);

// table_copy.wast:2641
assert_return(() => call($48, "test", [26]), 5);

// table_copy.wast:2642
assert_return(() => call($48, "test", [27]), 6);

// table_copy.wast:2643
assert_return(() => call($48, "test", [28]), 7);

// table_copy.wast:2644
assert_trap(() => call($48, "test", [29]));

// table_copy.wast:2645
assert_trap(() => call($48, "test", [30]));

// table_copy.wast:2646
assert_trap(() => call($48, "test", [31]));

// table_copy.wast:2648
let $49 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2674
assert_trap(() => call($49, "run", [21, 24, 16]));

// table_copy.wast:2676
assert_trap(() => call($49, "test", [0]));

// table_copy.wast:2677
assert_trap(() => call($49, "test", [1]));

// table_copy.wast:2678
assert_trap(() => call($49, "test", [2]));

// table_copy.wast:2679
assert_trap(() => call($49, "test", [3]));

// table_copy.wast:2680
assert_trap(() => call($49, "test", [4]));

// table_copy.wast:2681
assert_trap(() => call($49, "test", [5]));

// table_copy.wast:2682
assert_trap(() => call($49, "test", [6]));

// table_copy.wast:2683
assert_trap(() => call($49, "test", [7]));

// table_copy.wast:2684
assert_trap(() => call($49, "test", [8]));

// table_copy.wast:2685
assert_trap(() => call($49, "test", [9]));

// table_copy.wast:2686
assert_trap(() => call($49, "test", [10]));

// table_copy.wast:2687
assert_trap(() => call($49, "test", [11]));

// table_copy.wast:2688
assert_trap(() => call($49, "test", [12]));

// table_copy.wast:2689
assert_trap(() => call($49, "test", [13]));

// table_copy.wast:2690
assert_trap(() => call($49, "test", [14]));

// table_copy.wast:2691
assert_trap(() => call($49, "test", [15]));

// table_copy.wast:2692
assert_trap(() => call($49, "test", [16]));

// table_copy.wast:2693
assert_trap(() => call($49, "test", [17]));

// table_copy.wast:2694
assert_trap(() => call($49, "test", [18]));

// table_copy.wast:2695
assert_trap(() => call($49, "test", [19]));

// table_copy.wast:2696
assert_trap(() => call($49, "test", [20]));

// table_copy.wast:2697
assert_trap(() => call($49, "test", [21]));

// table_copy.wast:2698
assert_trap(() => call($49, "test", [22]));

// table_copy.wast:2699
assert_trap(() => call($49, "test", [23]));

// table_copy.wast:2700
assert_return(() => call($49, "test", [24]), 0);

// table_copy.wast:2701
assert_return(() => call($49, "test", [25]), 1);

// table_copy.wast:2702
assert_return(() => call($49, "test", [26]), 2);

// table_copy.wast:2703
assert_return(() => call($49, "test", [27]), 3);

// table_copy.wast:2704
assert_return(() => call($49, "test", [28]), 4);

// table_copy.wast:2705
assert_return(() => call($49, "test", [29]), 5);

// table_copy.wast:2706
assert_return(() => call($49, "test", [30]), 6);

// table_copy.wast:2707
assert_return(() => call($49, "test", [31]), 7);

// table_copy.wast:2709
let $50 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x91\x80\x80\x80\x00\x01\x00\x41\x15\x0b\x0b\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2735
assert_trap(() => call($50, "run", [21, 21, 16]));

// table_copy.wast:2737
assert_trap(() => call($50, "test", [0]));

// table_copy.wast:2738
assert_trap(() => call($50, "test", [1]));

// table_copy.wast:2739
assert_trap(() => call($50, "test", [2]));

// table_copy.wast:2740
assert_trap(() => call($50, "test", [3]));

// table_copy.wast:2741
assert_trap(() => call($50, "test", [4]));

// table_copy.wast:2742
assert_trap(() => call($50, "test", [5]));

// table_copy.wast:2743
assert_trap(() => call($50, "test", [6]));

// table_copy.wast:2744
assert_trap(() => call($50, "test", [7]));

// table_copy.wast:2745
assert_trap(() => call($50, "test", [8]));

// table_copy.wast:2746
assert_trap(() => call($50, "test", [9]));

// table_copy.wast:2747
assert_trap(() => call($50, "test", [10]));

// table_copy.wast:2748
assert_trap(() => call($50, "test", [11]));

// table_copy.wast:2749
assert_trap(() => call($50, "test", [12]));

// table_copy.wast:2750
assert_trap(() => call($50, "test", [13]));

// table_copy.wast:2751
assert_trap(() => call($50, "test", [14]));

// table_copy.wast:2752
assert_trap(() => call($50, "test", [15]));

// table_copy.wast:2753
assert_trap(() => call($50, "test", [16]));

// table_copy.wast:2754
assert_trap(() => call($50, "test", [17]));

// table_copy.wast:2755
assert_trap(() => call($50, "test", [18]));

// table_copy.wast:2756
assert_trap(() => call($50, "test", [19]));

// table_copy.wast:2757
assert_trap(() => call($50, "test", [20]));

// table_copy.wast:2758
assert_return(() => call($50, "test", [21]), 0);

// table_copy.wast:2759
assert_return(() => call($50, "test", [22]), 1);

// table_copy.wast:2760
assert_return(() => call($50, "test", [23]), 2);

// table_copy.wast:2761
assert_return(() => call($50, "test", [24]), 3);

// table_copy.wast:2762
assert_return(() => call($50, "test", [25]), 4);

// table_copy.wast:2763
assert_return(() => call($50, "test", [26]), 5);

// table_copy.wast:2764
assert_return(() => call($50, "test", [27]), 6);

// table_copy.wast:2765
assert_return(() => call($50, "test", [28]), 7);

// table_copy.wast:2766
assert_return(() => call($50, "test", [29]), 8);

// table_copy.wast:2767
assert_return(() => call($50, "test", [30]), 9);

// table_copy.wast:2768
assert_return(() => call($50, "test", [31]), 10);

// table_copy.wast:2770
let $51 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x87\x80\x80\x80\x00\x01\x70\x01\x80\x01\x80\x01\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x97\x80\x80\x80\x00\x01\x00\x41\xf0\x00\x0b\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2796
assert_trap(() => call($51, "run", [0, 112, -32]));

// table_copy.wast:2798
assert_trap(() => call($51, "test", [0]));

// table_copy.wast:2799
assert_trap(() => call($51, "test", [1]));

// table_copy.wast:2800
assert_trap(() => call($51, "test", [2]));

// table_copy.wast:2801
assert_trap(() => call($51, "test", [3]));

// table_copy.wast:2802
assert_trap(() => call($51, "test", [4]));

// table_copy.wast:2803
assert_trap(() => call($51, "test", [5]));

// table_copy.wast:2804
assert_trap(() => call($51, "test", [6]));

// table_copy.wast:2805
assert_trap(() => call($51, "test", [7]));

// table_copy.wast:2806
assert_trap(() => call($51, "test", [8]));

// table_copy.wast:2807
assert_trap(() => call($51, "test", [9]));

// table_copy.wast:2808
assert_trap(() => call($51, "test", [10]));

// table_copy.wast:2809
assert_trap(() => call($51, "test", [11]));

// table_copy.wast:2810
assert_trap(() => call($51, "test", [12]));

// table_copy.wast:2811
assert_trap(() => call($51, "test", [13]));

// table_copy.wast:2812
assert_trap(() => call($51, "test", [14]));

// table_copy.wast:2813
assert_trap(() => call($51, "test", [15]));

// table_copy.wast:2814
assert_trap(() => call($51, "test", [16]));

// table_copy.wast:2815
assert_trap(() => call($51, "test", [17]));

// table_copy.wast:2816
assert_trap(() => call($51, "test", [18]));

// table_copy.wast:2817
assert_trap(() => call($51, "test", [19]));

// table_copy.wast:2818
assert_trap(() => call($51, "test", [20]));

// table_copy.wast:2819
assert_trap(() => call($51, "test", [21]));

// table_copy.wast:2820
assert_trap(() => call($51, "test", [22]));

// table_copy.wast:2821
assert_trap(() => call($51, "test", [23]));

// table_copy.wast:2822
assert_trap(() => call($51, "test", [24]));

// table_copy.wast:2823
assert_trap(() => call($51, "test", [25]));

// table_copy.wast:2824
assert_trap(() => call($51, "test", [26]));

// table_copy.wast:2825
assert_trap(() => call($51, "test", [27]));

// table_copy.wast:2826
assert_trap(() => call($51, "test", [28]));

// table_copy.wast:2827
assert_trap(() => call($51, "test", [29]));

// table_copy.wast:2828
assert_trap(() => call($51, "test", [30]));

// table_copy.wast:2829
assert_trap(() => call($51, "test", [31]));

// table_copy.wast:2830
assert_trap(() => call($51, "test", [32]));

// table_copy.wast:2831
assert_trap(() => call($51, "test", [33]));

// table_copy.wast:2832
assert_trap(() => call($51, "test", [34]));

// table_copy.wast:2833
assert_trap(() => call($51, "test", [35]));

// table_copy.wast:2834
assert_trap(() => call($51, "test", [36]));

// table_copy.wast:2835
assert_trap(() => call($51, "test", [37]));

// table_copy.wast:2836
assert_trap(() => call($51, "test", [38]));

// table_copy.wast:2837
assert_trap(() => call($51, "test", [39]));

// table_copy.wast:2838
assert_trap(() => call($51, "test", [40]));

// table_copy.wast:2839
assert_trap(() => call($51, "test", [41]));

// table_copy.wast:2840
assert_trap(() => call($51, "test", [42]));

// table_copy.wast:2841
assert_trap(() => call($51, "test", [43]));

// table_copy.wast:2842
assert_trap(() => call($51, "test", [44]));

// table_copy.wast:2843
assert_trap(() => call($51, "test", [45]));

// table_copy.wast:2844
assert_trap(() => call($51, "test", [46]));

// table_copy.wast:2845
assert_trap(() => call($51, "test", [47]));

// table_copy.wast:2846
assert_trap(() => call($51, "test", [48]));

// table_copy.wast:2847
assert_trap(() => call($51, "test", [49]));

// table_copy.wast:2848
assert_trap(() => call($51, "test", [50]));

// table_copy.wast:2849
assert_trap(() => call($51, "test", [51]));

// table_copy.wast:2850
assert_trap(() => call($51, "test", [52]));

// table_copy.wast:2851
assert_trap(() => call($51, "test", [53]));

// table_copy.wast:2852
assert_trap(() => call($51, "test", [54]));

// table_copy.wast:2853
assert_trap(() => call($51, "test", [55]));

// table_copy.wast:2854
assert_trap(() => call($51, "test", [56]));

// table_copy.wast:2855
assert_trap(() => call($51, "test", [57]));

// table_copy.wast:2856
assert_trap(() => call($51, "test", [58]));

// table_copy.wast:2857
assert_trap(() => call($51, "test", [59]));

// table_copy.wast:2858
assert_trap(() => call($51, "test", [60]));

// table_copy.wast:2859
assert_trap(() => call($51, "test", [61]));

// table_copy.wast:2860
assert_trap(() => call($51, "test", [62]));

// table_copy.wast:2861
assert_trap(() => call($51, "test", [63]));

// table_copy.wast:2862
assert_trap(() => call($51, "test", [64]));

// table_copy.wast:2863
assert_trap(() => call($51, "test", [65]));

// table_copy.wast:2864
assert_trap(() => call($51, "test", [66]));

// table_copy.wast:2865
assert_trap(() => call($51, "test", [67]));

// table_copy.wast:2866
assert_trap(() => call($51, "test", [68]));

// table_copy.wast:2867
assert_trap(() => call($51, "test", [69]));

// table_copy.wast:2868
assert_trap(() => call($51, "test", [70]));

// table_copy.wast:2869
assert_trap(() => call($51, "test", [71]));

// table_copy.wast:2870
assert_trap(() => call($51, "test", [72]));

// table_copy.wast:2871
assert_trap(() => call($51, "test", [73]));

// table_copy.wast:2872
assert_trap(() => call($51, "test", [74]));

// table_copy.wast:2873
assert_trap(() => call($51, "test", [75]));

// table_copy.wast:2874
assert_trap(() => call($51, "test", [76]));

// table_copy.wast:2875
assert_trap(() => call($51, "test", [77]));

// table_copy.wast:2876
assert_trap(() => call($51, "test", [78]));

// table_copy.wast:2877
assert_trap(() => call($51, "test", [79]));

// table_copy.wast:2878
assert_trap(() => call($51, "test", [80]));

// table_copy.wast:2879
assert_trap(() => call($51, "test", [81]));

// table_copy.wast:2880
assert_trap(() => call($51, "test", [82]));

// table_copy.wast:2881
assert_trap(() => call($51, "test", [83]));

// table_copy.wast:2882
assert_trap(() => call($51, "test", [84]));

// table_copy.wast:2883
assert_trap(() => call($51, "test", [85]));

// table_copy.wast:2884
assert_trap(() => call($51, "test", [86]));

// table_copy.wast:2885
assert_trap(() => call($51, "test", [87]));

// table_copy.wast:2886
assert_trap(() => call($51, "test", [88]));

// table_copy.wast:2887
assert_trap(() => call($51, "test", [89]));

// table_copy.wast:2888
assert_trap(() => call($51, "test", [90]));

// table_copy.wast:2889
assert_trap(() => call($51, "test", [91]));

// table_copy.wast:2890
assert_trap(() => call($51, "test", [92]));

// table_copy.wast:2891
assert_trap(() => call($51, "test", [93]));

// table_copy.wast:2892
assert_trap(() => call($51, "test", [94]));

// table_copy.wast:2893
assert_trap(() => call($51, "test", [95]));

// table_copy.wast:2894
assert_trap(() => call($51, "test", [96]));

// table_copy.wast:2895
assert_trap(() => call($51, "test", [97]));

// table_copy.wast:2896
assert_trap(() => call($51, "test", [98]));

// table_copy.wast:2897
assert_trap(() => call($51, "test", [99]));

// table_copy.wast:2898
assert_trap(() => call($51, "test", [100]));

// table_copy.wast:2899
assert_trap(() => call($51, "test", [101]));

// table_copy.wast:2900
assert_trap(() => call($51, "test", [102]));

// table_copy.wast:2901
assert_trap(() => call($51, "test", [103]));

// table_copy.wast:2902
assert_trap(() => call($51, "test", [104]));

// table_copy.wast:2903
assert_trap(() => call($51, "test", [105]));

// table_copy.wast:2904
assert_trap(() => call($51, "test", [106]));

// table_copy.wast:2905
assert_trap(() => call($51, "test", [107]));

// table_copy.wast:2906
assert_trap(() => call($51, "test", [108]));

// table_copy.wast:2907
assert_trap(() => call($51, "test", [109]));

// table_copy.wast:2908
assert_trap(() => call($51, "test", [110]));

// table_copy.wast:2909
assert_trap(() => call($51, "test", [111]));

// table_copy.wast:2910
assert_return(() => call($51, "test", [112]), 0);

// table_copy.wast:2911
assert_return(() => call($51, "test", [113]), 1);

// table_copy.wast:2912
assert_return(() => call($51, "test", [114]), 2);

// table_copy.wast:2913
assert_return(() => call($51, "test", [115]), 3);

// table_copy.wast:2914
assert_return(() => call($51, "test", [116]), 4);

// table_copy.wast:2915
assert_return(() => call($51, "test", [117]), 5);

// table_copy.wast:2916
assert_return(() => call($51, "test", [118]), 6);

// table_copy.wast:2917
assert_return(() => call($51, "test", [119]), 7);

// table_copy.wast:2918
assert_return(() => call($51, "test", [120]), 8);

// table_copy.wast:2919
assert_return(() => call($51, "test", [121]), 9);

// table_copy.wast:2920
assert_return(() => call($51, "test", [122]), 10);

// table_copy.wast:2921
assert_return(() => call($51, "test", [123]), 11);

// table_copy.wast:2922
assert_return(() => call($51, "test", [124]), 12);

// table_copy.wast:2923
assert_return(() => call($51, "test", [125]), 13);

// table_copy.wast:2924
assert_return(() => call($51, "test", [126]), 14);

// table_copy.wast:2925
assert_return(() => call($51, "test", [127]), 15);

// table_copy.wast:2927
let $52 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x87\x80\x80\x80\x00\x01\x70\x01\x80\x01\x80\x01\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x96\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2953
assert_trap(() => call($52, "run", [112, 0, -32]));

// table_copy.wast:2955
assert_return(() => call($52, "test", [0]), 0);

// table_copy.wast:2956
assert_return(() => call($52, "test", [1]), 1);

// table_copy.wast:2957
assert_return(() => call($52, "test", [2]), 2);

// table_copy.wast:2958
assert_return(() => call($52, "test", [3]), 3);

// table_copy.wast:2959
assert_return(() => call($52, "test", [4]), 4);

// table_copy.wast:2960
assert_return(() => call($52, "test", [5]), 5);

// table_copy.wast:2961
assert_return(() => call($52, "test", [6]), 6);

// table_copy.wast:2962
assert_return(() => call($52, "test", [7]), 7);

// table_copy.wast:2963
assert_return(() => call($52, "test", [8]), 8);

// table_copy.wast:2964
assert_return(() => call($52, "test", [9]), 9);

// table_copy.wast:2965
assert_return(() => call($52, "test", [10]), 10);

// table_copy.wast:2966
assert_return(() => call($52, "test", [11]), 11);

// table_copy.wast:2967
assert_return(() => call($52, "test", [12]), 12);

// table_copy.wast:2968
assert_return(() => call($52, "test", [13]), 13);

// table_copy.wast:2969
assert_return(() => call($52, "test", [14]), 14);

// table_copy.wast:2970
assert_return(() => call($52, "test", [15]), 15);

// table_copy.wast:2971
assert_trap(() => call($52, "test", [16]));

// table_copy.wast:2972
assert_trap(() => call($52, "test", [17]));

// table_copy.wast:2973
assert_trap(() => call($52, "test", [18]));

// table_copy.wast:2974
assert_trap(() => call($52, "test", [19]));

// table_copy.wast:2975
assert_trap(() => call($52, "test", [20]));

// table_copy.wast:2976
assert_trap(() => call($52, "test", [21]));

// table_copy.wast:2977
assert_trap(() => call($52, "test", [22]));

// table_copy.wast:2978
assert_trap(() => call($52, "test", [23]));

// table_copy.wast:2979
assert_trap(() => call($52, "test", [24]));

// table_copy.wast:2980
assert_trap(() => call($52, "test", [25]));

// table_copy.wast:2981
assert_trap(() => call($52, "test", [26]));

// table_copy.wast:2982
assert_trap(() => call($52, "test", [27]));

// table_copy.wast:2983
assert_trap(() => call($52, "test", [28]));

// table_copy.wast:2984
assert_trap(() => call($52, "test", [29]));

// table_copy.wast:2985
assert_trap(() => call($52, "test", [30]));

// table_copy.wast:2986
assert_trap(() => call($52, "test", [31]));

// table_copy.wast:2987
assert_trap(() => call($52, "test", [32]));

// table_copy.wast:2988
assert_trap(() => call($52, "test", [33]));

// table_copy.wast:2989
assert_trap(() => call($52, "test", [34]));

// table_copy.wast:2990
assert_trap(() => call($52, "test", [35]));

// table_copy.wast:2991
assert_trap(() => call($52, "test", [36]));

// table_copy.wast:2992
assert_trap(() => call($52, "test", [37]));

// table_copy.wast:2993
assert_trap(() => call($52, "test", [38]));

// table_copy.wast:2994
assert_trap(() => call($52, "test", [39]));

// table_copy.wast:2995
assert_trap(() => call($52, "test", [40]));

// table_copy.wast:2996
assert_trap(() => call($52, "test", [41]));

// table_copy.wast:2997
assert_trap(() => call($52, "test", [42]));

// table_copy.wast:2998
assert_trap(() => call($52, "test", [43]));

// table_copy.wast:2999
assert_trap(() => call($52, "test", [44]));

// table_copy.wast:3000
assert_trap(() => call($52, "test", [45]));

// table_copy.wast:3001
assert_trap(() => call($52, "test", [46]));

// table_copy.wast:3002
assert_trap(() => call($52, "test", [47]));

// table_copy.wast:3003
assert_trap(() => call($52, "test", [48]));

// table_copy.wast:3004
assert_trap(() => call($52, "test", [49]));

// table_copy.wast:3005
assert_trap(() => call($52, "test", [50]));

// table_copy.wast:3006
assert_trap(() => call($52, "test", [51]));

// table_copy.wast:3007
assert_trap(() => call($52, "test", [52]));

// table_copy.wast:3008
assert_trap(() => call($52, "test", [53]));

// table_copy.wast:3009
assert_trap(() => call($52, "test", [54]));

// table_copy.wast:3010
assert_trap(() => call($52, "test", [55]));

// table_copy.wast:3011
assert_trap(() => call($52, "test", [56]));

// table_copy.wast:3012
assert_trap(() => call($52, "test", [57]));

// table_copy.wast:3013
assert_trap(() => call($52, "test", [58]));

// table_copy.wast:3014
assert_trap(() => call($52, "test", [59]));

// table_copy.wast:3015
assert_trap(() => call($52, "test", [60]));

// table_copy.wast:3016
assert_trap(() => call($52, "test", [61]));

// table_copy.wast:3017
assert_trap(() => call($52, "test", [62]));

// table_copy.wast:3018
assert_trap(() => call($52, "test", [63]));

// table_copy.wast:3019
assert_trap(() => call($52, "test", [64]));

// table_copy.wast:3020
assert_trap(() => call($52, "test", [65]));

// table_copy.wast:3021
assert_trap(() => call($52, "test", [66]));

// table_copy.wast:3022
assert_trap(() => call($52, "test", [67]));

// table_copy.wast:3023
assert_trap(() => call($52, "test", [68]));

// table_copy.wast:3024
assert_trap(() => call($52, "test", [69]));

// table_copy.wast:3025
assert_trap(() => call($52, "test", [70]));

// table_copy.wast:3026
assert_trap(() => call($52, "test", [71]));

// table_copy.wast:3027
assert_trap(() => call($52, "test", [72]));

// table_copy.wast:3028
assert_trap(() => call($52, "test", [73]));

// table_copy.wast:3029
assert_trap(() => call($52, "test", [74]));

// table_copy.wast:3030
assert_trap(() => call($52, "test", [75]));

// table_copy.wast:3031
assert_trap(() => call($52, "test", [76]));

// table_copy.wast:3032
assert_trap(() => call($52, "test", [77]));

// table_copy.wast:3033
assert_trap(() => call($52, "test", [78]));

// table_copy.wast:3034
assert_trap(() => call($52, "test", [79]));

// table_copy.wast:3035
assert_trap(() => call($52, "test", [80]));

// table_copy.wast:3036
assert_trap(() => call($52, "test", [81]));

// table_copy.wast:3037
assert_trap(() => call($52, "test", [82]));

// table_copy.wast:3038
assert_trap(() => call($52, "test", [83]));

// table_copy.wast:3039
assert_trap(() => call($52, "test", [84]));

// table_copy.wast:3040
assert_trap(() => call($52, "test", [85]));

// table_copy.wast:3041
assert_trap(() => call($52, "test", [86]));

// table_copy.wast:3042
assert_trap(() => call($52, "test", [87]));

// table_copy.wast:3043
assert_trap(() => call($52, "test", [88]));

// table_copy.wast:3044
assert_trap(() => call($52, "test", [89]));

// table_copy.wast:3045
assert_trap(() => call($52, "test", [90]));

// table_copy.wast:3046
assert_trap(() => call($52, "test", [91]));

// table_copy.wast:3047
assert_trap(() => call($52, "test", [92]));

// table_copy.wast:3048
assert_trap(() => call($52, "test", [93]));

// table_copy.wast:3049
assert_trap(() => call($52, "test", [94]));

// table_copy.wast:3050
assert_trap(() => call($52, "test", [95]));

// table_copy.wast:3051
assert_trap(() => call($52, "test", [96]));

// table_copy.wast:3052
assert_trap(() => call($52, "test", [97]));

// table_copy.wast:3053
assert_trap(() => call($52, "test", [98]));

// table_copy.wast:3054
assert_trap(() => call($52, "test", [99]));

// table_copy.wast:3055
assert_trap(() => call($52, "test", [100]));

// table_copy.wast:3056
assert_trap(() => call($52, "test", [101]));

// table_copy.wast:3057
assert_trap(() => call($52, "test", [102]));

// table_copy.wast:3058
assert_trap(() => call($52, "test", [103]));

// table_copy.wast:3059
assert_trap(() => call($52, "test", [104]));

// table_copy.wast:3060
assert_trap(() => call($52, "test", [105]));

// table_copy.wast:3061
assert_trap(() => call($52, "test", [106]));

// table_copy.wast:3062
assert_trap(() => call($52, "test", [107]));

// table_copy.wast:3063
assert_trap(() => call($52, "test", [108]));

// table_copy.wast:3064
assert_trap(() => call($52, "test", [109]));

// table_copy.wast:3065
assert_trap(() => call($52, "test", [110]));

// table_copy.wast:3066
assert_trap(() => call($52, "test", [111]));

// table_copy.wast:3067
assert_trap(() => call($52, "test", [112]));

// table_copy.wast:3068
assert_trap(() => call($52, "test", [113]));

// table_copy.wast:3069
assert_trap(() => call($52, "test", [114]));

// table_copy.wast:3070
assert_trap(() => call($52, "test", [115]));

// table_copy.wast:3071
assert_trap(() => call($52, "test", [116]));

// table_copy.wast:3072
assert_trap(() => call($52, "test", [117]));

// table_copy.wast:3073
assert_trap(() => call($52, "test", [118]));

// table_copy.wast:3074
assert_trap(() => call($52, "test", [119]));

// table_copy.wast:3075
assert_trap(() => call($52, "test", [120]));

// table_copy.wast:3076
assert_trap(() => call($52, "test", [121]));

// table_copy.wast:3077
assert_trap(() => call($52, "test", [122]));

// table_copy.wast:3078
assert_trap(() => call($52, "test", [123]));

// table_copy.wast:3079
assert_trap(() => call($52, "test", [124]));

// table_copy.wast:3080
assert_trap(() => call($52, "test", [125]));

// table_copy.wast:3081
assert_trap(() => call($52, "test", [126]));

// table_copy.wast:3082
assert_trap(() => call($52, "test", [127]));




// table_copy.wast:6
let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x86\x80\x80\x80\x00\x05\x00\x00\x00\x00\x00\x07\x9f\x80\x80\x80\x00\x05\x03\x65\x66\x30\x00\x00\x03\x65\x66\x31\x00\x01\x03\x65\x66\x32\x00\x02\x03\x65\x66\x33\x00\x03\x03\x65\x66\x34\x00\x04\x0a\xae\x80\x80\x80\x00\x05\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b");

// table_copy.wast:13
register("a", $1)

// table_copy.wast:15
let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xce\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x83\x80\x80\x80\x00\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:45
run(() => call($2, "test", []));

// table_copy.wast:46
assert_trap(() => call($2, "check_t0", [0]));

// table_copy.wast:47
assert_trap(() => call($2, "check_t0", [1]));

// table_copy.wast:48
assert_return(() => call($2, "check_t0", [2]), 3);

// table_copy.wast:49
assert_return(() => call($2, "check_t0", [3]), 1);

// table_copy.wast:50
assert_return(() => call($2, "check_t0", [4]), 4);

// table_copy.wast:51
assert_return(() => call($2, "check_t0", [5]), 1);

// table_copy.wast:52
assert_trap(() => call($2, "check_t0", [6]));

// table_copy.wast:53
assert_trap(() => call($2, "check_t0", [7]));

// table_copy.wast:54
assert_trap(() => call($2, "check_t0", [8]));

// table_copy.wast:55
assert_trap(() => call($2, "check_t0", [9]));

// table_copy.wast:56
assert_trap(() => call($2, "check_t0", [10]));

// table_copy.wast:57
assert_trap(() => call($2, "check_t0", [11]));

// table_copy.wast:58
assert_return(() => call($2, "check_t0", [12]), 7);

// table_copy.wast:59
assert_return(() => call($2, "check_t0", [13]), 5);

// table_copy.wast:60
assert_return(() => call($2, "check_t0", [14]), 2);

// table_copy.wast:61
assert_return(() => call($2, "check_t0", [15]), 3);

// table_copy.wast:62
assert_return(() => call($2, "check_t0", [16]), 6);

// table_copy.wast:63
assert_trap(() => call($2, "check_t0", [17]));

// table_copy.wast:64
assert_trap(() => call($2, "check_t0", [18]));

// table_copy.wast:65
assert_trap(() => call($2, "check_t0", [19]));

// table_copy.wast:66
assert_trap(() => call($2, "check_t0", [20]));

// table_copy.wast:67
assert_trap(() => call($2, "check_t0", [21]));

// table_copy.wast:68
assert_trap(() => call($2, "check_t0", [22]));

// table_copy.wast:69
assert_trap(() => call($2, "check_t0", [23]));

// table_copy.wast:70
assert_trap(() => call($2, "check_t0", [24]));

// table_copy.wast:71
assert_trap(() => call($2, "check_t0", [25]));

// table_copy.wast:72
assert_trap(() => call($2, "check_t0", [26]));

// table_copy.wast:73
assert_trap(() => call($2, "check_t0", [27]));

// table_copy.wast:74
assert_trap(() => call($2, "check_t0", [28]));

// table_copy.wast:75
assert_trap(() => call($2, "check_t0", [29]));

// table_copy.wast:76
assert_trap(() => call($2, "check_t1", [0]));

// table_copy.wast:77
assert_trap(() => call($2, "check_t1", [1]));

// table_copy.wast:78
assert_trap(() => call($2, "check_t1", [2]));

// table_copy.wast:79
assert_return(() => call($2, "check_t1", [3]), 1);

// table_copy.wast:80
assert_return(() => call($2, "check_t1", [4]), 3);

// table_copy.wast:81
assert_return(() => call($2, "check_t1", [5]), 1);

// table_copy.wast:82
assert_return(() => call($2, "check_t1", [6]), 4);

// table_copy.wast:83
assert_trap(() => call($2, "check_t1", [7]));

// table_copy.wast:84
assert_trap(() => call($2, "check_t1", [8]));

// table_copy.wast:85
assert_trap(() => call($2, "check_t1", [9]));

// table_copy.wast:86
assert_trap(() => call($2, "check_t1", [10]));

// table_copy.wast:87
assert_return(() => call($2, "check_t1", [11]), 6);

// table_copy.wast:88
assert_return(() => call($2, "check_t1", [12]), 3);

// table_copy.wast:89
assert_return(() => call($2, "check_t1", [13]), 2);

// table_copy.wast:90
assert_return(() => call($2, "check_t1", [14]), 5);

// table_copy.wast:91
assert_return(() => call($2, "check_t1", [15]), 7);

// table_copy.wast:92
assert_trap(() => call($2, "check_t1", [16]));

// table_copy.wast:93
assert_trap(() => call($2, "check_t1", [17]));

// table_copy.wast:94
assert_trap(() => call($2, "check_t1", [18]));

// table_copy.wast:95
assert_trap(() => call($2, "check_t1", [19]));

// table_copy.wast:96
assert_trap(() => call($2, "check_t1", [20]));

// table_copy.wast:97
assert_trap(() => call($2, "check_t1", [21]));

// table_copy.wast:98
assert_trap(() => call($2, "check_t1", [22]));

// table_copy.wast:99
assert_trap(() => call($2, "check_t1", [23]));

// table_copy.wast:100
assert_trap(() => call($2, "check_t1", [24]));

// table_copy.wast:101
assert_trap(() => call($2, "check_t1", [25]));

// table_copy.wast:102
assert_trap(() => call($2, "check_t1", [26]));

// table_copy.wast:103
assert_trap(() => call($2, "check_t1", [27]));

// table_copy.wast:104
assert_trap(() => call($2, "check_t1", [28]));

// table_copy.wast:105
assert_trap(() => call($2, "check_t1", [29]));

// table_copy.wast:107
let $3 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x02\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:137
run(() => call($3, "test", []));

// table_copy.wast:138
assert_trap(() => call($3, "check_t0", [0]));

// table_copy.wast:139
assert_trap(() => call($3, "check_t0", [1]));

// table_copy.wast:140
assert_return(() => call($3, "check_t0", [2]), 3);

// table_copy.wast:141
assert_return(() => call($3, "check_t0", [3]), 1);

// table_copy.wast:142
assert_return(() => call($3, "check_t0", [4]), 4);

// table_copy.wast:143
assert_return(() => call($3, "check_t0", [5]), 1);

// table_copy.wast:144
assert_trap(() => call($3, "check_t0", [6]));

// table_copy.wast:145
assert_trap(() => call($3, "check_t0", [7]));

// table_copy.wast:146
assert_trap(() => call($3, "check_t0", [8]));

// table_copy.wast:147
assert_trap(() => call($3, "check_t0", [9]));

// table_copy.wast:148
assert_trap(() => call($3, "check_t0", [10]));

// table_copy.wast:149
assert_trap(() => call($3, "check_t0", [11]));

// table_copy.wast:150
assert_return(() => call($3, "check_t0", [12]), 7);

// table_copy.wast:151
assert_return(() => call($3, "check_t0", [13]), 3);

// table_copy.wast:152
assert_return(() => call($3, "check_t0", [14]), 1);

// table_copy.wast:153
assert_return(() => call($3, "check_t0", [15]), 4);

// table_copy.wast:154
assert_return(() => call($3, "check_t0", [16]), 6);

// table_copy.wast:155
assert_trap(() => call($3, "check_t0", [17]));

// table_copy.wast:156
assert_trap(() => call($3, "check_t0", [18]));

// table_copy.wast:157
assert_trap(() => call($3, "check_t0", [19]));

// table_copy.wast:158
assert_trap(() => call($3, "check_t0", [20]));

// table_copy.wast:159
assert_trap(() => call($3, "check_t0", [21]));

// table_copy.wast:160
assert_trap(() => call($3, "check_t0", [22]));

// table_copy.wast:161
assert_trap(() => call($3, "check_t0", [23]));

// table_copy.wast:162
assert_trap(() => call($3, "check_t0", [24]));

// table_copy.wast:163
assert_trap(() => call($3, "check_t0", [25]));

// table_copy.wast:164
assert_trap(() => call($3, "check_t0", [26]));

// table_copy.wast:165
assert_trap(() => call($3, "check_t0", [27]));

// table_copy.wast:166
assert_trap(() => call($3, "check_t0", [28]));

// table_copy.wast:167
assert_trap(() => call($3, "check_t0", [29]));

// table_copy.wast:168
assert_trap(() => call($3, "check_t1", [0]));

// table_copy.wast:169
assert_trap(() => call($3, "check_t1", [1]));

// table_copy.wast:170
assert_trap(() => call($3, "check_t1", [2]));

// table_copy.wast:171
assert_return(() => call($3, "check_t1", [3]), 1);

// table_copy.wast:172
assert_return(() => call($3, "check_t1", [4]), 3);

// table_copy.wast:173
assert_return(() => call($3, "check_t1", [5]), 1);

// table_copy.wast:174
assert_return(() => call($3, "check_t1", [6]), 4);

// table_copy.wast:175
assert_trap(() => call($3, "check_t1", [7]));

// table_copy.wast:176
assert_trap(() => call($3, "check_t1", [8]));

// table_copy.wast:177
assert_trap(() => call($3, "check_t1", [9]));

// table_copy.wast:178
assert_trap(() => call($3, "check_t1", [10]));

// table_copy.wast:179
assert_return(() => call($3, "check_t1", [11]), 6);

// table_copy.wast:180
assert_return(() => call($3, "check_t1", [12]), 3);

// table_copy.wast:181
assert_return(() => call($3, "check_t1", [13]), 2);

// table_copy.wast:182
assert_return(() => call($3, "check_t1", [14]), 5);

// table_copy.wast:183
assert_return(() => call($3, "check_t1", [15]), 7);

// table_copy.wast:184
assert_trap(() => call($3, "check_t1", [16]));

// table_copy.wast:185
assert_trap(() => call($3, "check_t1", [17]));

// table_copy.wast:186
assert_trap(() => call($3, "check_t1", [18]));

// table_copy.wast:187
assert_trap(() => call($3, "check_t1", [19]));

// table_copy.wast:188
assert_trap(() => call($3, "check_t1", [20]));

// table_copy.wast:189
assert_trap(() => call($3, "check_t1", [21]));

// table_copy.wast:190
assert_trap(() => call($3, "check_t1", [22]));

// table_copy.wast:191
assert_trap(() => call($3, "check_t1", [23]));

// table_copy.wast:192
assert_trap(() => call($3, "check_t1", [24]));

// table_copy.wast:193
assert_trap(() => call($3, "check_t1", [25]));

// table_copy.wast:194
assert_trap(() => call($3, "check_t1", [26]));

// table_copy.wast:195
assert_trap(() => call($3, "check_t1", [27]));

// table_copy.wast:196
assert_trap(() => call($3, "check_t1", [28]));

// table_copy.wast:197
assert_trap(() => call($3, "check_t1", [29]));

// table_copy.wast:199
let $4 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x0f\x41\x02\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:229
run(() => call($4, "test", []));

// table_copy.wast:230
assert_trap(() => call($4, "check_t0", [0]));

// table_copy.wast:231
assert_trap(() => call($4, "check_t0", [1]));

// table_copy.wast:232
assert_return(() => call($4, "check_t0", [2]), 3);

// table_copy.wast:233
assert_return(() => call($4, "check_t0", [3]), 1);

// table_copy.wast:234
assert_return(() => call($4, "check_t0", [4]), 4);

// table_copy.wast:235
assert_return(() => call($4, "check_t0", [5]), 1);

// table_copy.wast:236
assert_trap(() => call($4, "check_t0", [6]));

// table_copy.wast:237
assert_trap(() => call($4, "check_t0", [7]));

// table_copy.wast:238
assert_trap(() => call($4, "check_t0", [8]));

// table_copy.wast:239
assert_trap(() => call($4, "check_t0", [9]));

// table_copy.wast:240
assert_trap(() => call($4, "check_t0", [10]));

// table_copy.wast:241
assert_trap(() => call($4, "check_t0", [11]));

// table_copy.wast:242
assert_return(() => call($4, "check_t0", [12]), 7);

// table_copy.wast:243
assert_return(() => call($4, "check_t0", [13]), 5);

// table_copy.wast:244
assert_return(() => call($4, "check_t0", [14]), 2);

// table_copy.wast:245
assert_return(() => call($4, "check_t0", [15]), 3);

// table_copy.wast:246
assert_return(() => call($4, "check_t0", [16]), 6);

// table_copy.wast:247
assert_trap(() => call($4, "check_t0", [17]));

// table_copy.wast:248
assert_trap(() => call($4, "check_t0", [18]));

// table_copy.wast:249
assert_trap(() => call($4, "check_t0", [19]));

// table_copy.wast:250
assert_trap(() => call($4, "check_t0", [20]));

// table_copy.wast:251
assert_trap(() => call($4, "check_t0", [21]));

// table_copy.wast:252
assert_trap(() => call($4, "check_t0", [22]));

// table_copy.wast:253
assert_trap(() => call($4, "check_t0", [23]));

// table_copy.wast:254
assert_trap(() => call($4, "check_t0", [24]));

// table_copy.wast:255
assert_return(() => call($4, "check_t0", [25]), 3);

// table_copy.wast:256
assert_return(() => call($4, "check_t0", [26]), 6);

// table_copy.wast:257
assert_trap(() => call($4, "check_t0", [27]));

// table_copy.wast:258
assert_trap(() => call($4, "check_t0", [28]));

// table_copy.wast:259
assert_trap(() => call($4, "check_t0", [29]));

// table_copy.wast:260
assert_trap(() => call($4, "check_t1", [0]));

// table_copy.wast:261
assert_trap(() => call($4, "check_t1", [1]));

// table_copy.wast:262
assert_trap(() => call($4, "check_t1", [2]));

// table_copy.wast:263
assert_return(() => call($4, "check_t1", [3]), 1);

// table_copy.wast:264
assert_return(() => call($4, "check_t1", [4]), 3);

// table_copy.wast:265
assert_return(() => call($4, "check_t1", [5]), 1);

// table_copy.wast:266
assert_return(() => call($4, "check_t1", [6]), 4);

// table_copy.wast:267
assert_trap(() => call($4, "check_t1", [7]));

// table_copy.wast:268
assert_trap(() => call($4, "check_t1", [8]));

// table_copy.wast:269
assert_trap(() => call($4, "check_t1", [9]));

// table_copy.wast:270
assert_trap(() => call($4, "check_t1", [10]));

// table_copy.wast:271
assert_return(() => call($4, "check_t1", [11]), 6);

// table_copy.wast:272
assert_return(() => call($4, "check_t1", [12]), 3);

// table_copy.wast:273
assert_return(() => call($4, "check_t1", [13]), 2);

// table_copy.wast:274
assert_return(() => call($4, "check_t1", [14]), 5);

// table_copy.wast:275
assert_return(() => call($4, "check_t1", [15]), 7);

// table_copy.wast:276
assert_trap(() => call($4, "check_t1", [16]));

// table_copy.wast:277
assert_trap(() => call($4, "check_t1", [17]));

// table_copy.wast:278
assert_trap(() => call($4, "check_t1", [18]));

// table_copy.wast:279
assert_trap(() => call($4, "check_t1", [19]));

// table_copy.wast:280
assert_trap(() => call($4, "check_t1", [20]));

// table_copy.wast:281
assert_trap(() => call($4, "check_t1", [21]));

// table_copy.wast:282
assert_trap(() => call($4, "check_t1", [22]));

// table_copy.wast:283
assert_trap(() => call($4, "check_t1", [23]));

// table_copy.wast:284
assert_trap(() => call($4, "check_t1", [24]));

// table_copy.wast:285
assert_trap(() => call($4, "check_t1", [25]));

// table_copy.wast:286
assert_trap(() => call($4, "check_t1", [26]));

// table_copy.wast:287
assert_trap(() => call($4, "check_t1", [27]));

// table_copy.wast:288
assert_trap(() => call($4, "check_t1", [28]));

// table_copy.wast:289
assert_trap(() => call($4, "check_t1", [29]));

// table_copy.wast:291
let $5 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x19\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:321
run(() => call($5, "test", []));

// table_copy.wast:322
assert_trap(() => call($5, "check_t0", [0]));

// table_copy.wast:323
assert_trap(() => call($5, "check_t0", [1]));

// table_copy.wast:324
assert_return(() => call($5, "check_t0", [2]), 3);

// table_copy.wast:325
assert_return(() => call($5, "check_t0", [3]), 1);

// table_copy.wast:326
assert_return(() => call($5, "check_t0", [4]), 4);

// table_copy.wast:327
assert_return(() => call($5, "check_t0", [5]), 1);

// table_copy.wast:328
assert_trap(() => call($5, "check_t0", [6]));

// table_copy.wast:329
assert_trap(() => call($5, "check_t0", [7]));

// table_copy.wast:330
assert_trap(() => call($5, "check_t0", [8]));

// table_copy.wast:331
assert_trap(() => call($5, "check_t0", [9]));

// table_copy.wast:332
assert_trap(() => call($5, "check_t0", [10]));

// table_copy.wast:333
assert_trap(() => call($5, "check_t0", [11]));

// table_copy.wast:334
assert_return(() => call($5, "check_t0", [12]), 7);

// table_copy.wast:335
assert_trap(() => call($5, "check_t0", [13]));

// table_copy.wast:336
assert_trap(() => call($5, "check_t0", [14]));

// table_copy.wast:337
assert_trap(() => call($5, "check_t0", [15]));

// table_copy.wast:338
assert_return(() => call($5, "check_t0", [16]), 6);

// table_copy.wast:339
assert_trap(() => call($5, "check_t0", [17]));

// table_copy.wast:340
assert_trap(() => call($5, "check_t0", [18]));

// table_copy.wast:341
assert_trap(() => call($5, "check_t0", [19]));

// table_copy.wast:342
assert_trap(() => call($5, "check_t0", [20]));

// table_copy.wast:343
assert_trap(() => call($5, "check_t0", [21]));

// table_copy.wast:344
assert_trap(() => call($5, "check_t0", [22]));

// table_copy.wast:345
assert_trap(() => call($5, "check_t0", [23]));

// table_copy.wast:346
assert_trap(() => call($5, "check_t0", [24]));

// table_copy.wast:347
assert_trap(() => call($5, "check_t0", [25]));

// table_copy.wast:348
assert_trap(() => call($5, "check_t0", [26]));

// table_copy.wast:349
assert_trap(() => call($5, "check_t0", [27]));

// table_copy.wast:350
assert_trap(() => call($5, "check_t0", [28]));

// table_copy.wast:351
assert_trap(() => call($5, "check_t0", [29]));

// table_copy.wast:352
assert_trap(() => call($5, "check_t1", [0]));

// table_copy.wast:353
assert_trap(() => call($5, "check_t1", [1]));

// table_copy.wast:354
assert_trap(() => call($5, "check_t1", [2]));

// table_copy.wast:355
assert_return(() => call($5, "check_t1", [3]), 1);

// table_copy.wast:356
assert_return(() => call($5, "check_t1", [4]), 3);

// table_copy.wast:357
assert_return(() => call($5, "check_t1", [5]), 1);

// table_copy.wast:358
assert_return(() => call($5, "check_t1", [6]), 4);

// table_copy.wast:359
assert_trap(() => call($5, "check_t1", [7]));

// table_copy.wast:360
assert_trap(() => call($5, "check_t1", [8]));

// table_copy.wast:361
assert_trap(() => call($5, "check_t1", [9]));

// table_copy.wast:362
assert_trap(() => call($5, "check_t1", [10]));

// table_copy.wast:363
assert_return(() => call($5, "check_t1", [11]), 6);

// table_copy.wast:364
assert_return(() => call($5, "check_t1", [12]), 3);

// table_copy.wast:365
assert_return(() => call($5, "check_t1", [13]), 2);

// table_copy.wast:366
assert_return(() => call($5, "check_t1", [14]), 5);

// table_copy.wast:367
assert_return(() => call($5, "check_t1", [15]), 7);

// table_copy.wast:368
assert_trap(() => call($5, "check_t1", [16]));

// table_copy.wast:369
assert_trap(() => call($5, "check_t1", [17]));

// table_copy.wast:370
assert_trap(() => call($5, "check_t1", [18]));

// table_copy.wast:371
assert_trap(() => call($5, "check_t1", [19]));

// table_copy.wast:372
assert_trap(() => call($5, "check_t1", [20]));

// table_copy.wast:373
assert_trap(() => call($5, "check_t1", [21]));

// table_copy.wast:374
assert_trap(() => call($5, "check_t1", [22]));

// table_copy.wast:375
assert_trap(() => call($5, "check_t1", [23]));

// table_copy.wast:376
assert_trap(() => call($5, "check_t1", [24]));

// table_copy.wast:377
assert_trap(() => call($5, "check_t1", [25]));

// table_copy.wast:378
assert_trap(() => call($5, "check_t1", [26]));

// table_copy.wast:379
assert_trap(() => call($5, "check_t1", [27]));

// table_copy.wast:380
assert_trap(() => call($5, "check_t1", [28]));

// table_copy.wast:381
assert_trap(() => call($5, "check_t1", [29]));

// table_copy.wast:383
let $6 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x14\x41\x16\x41\x04\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:413
run(() => call($6, "test", []));

// table_copy.wast:414
assert_trap(() => call($6, "check_t0", [0]));

// table_copy.wast:415
assert_trap(() => call($6, "check_t0", [1]));

// table_copy.wast:416
assert_return(() => call($6, "check_t0", [2]), 3);

// table_copy.wast:417
assert_return(() => call($6, "check_t0", [3]), 1);

// table_copy.wast:418
assert_return(() => call($6, "check_t0", [4]), 4);

// table_copy.wast:419
assert_return(() => call($6, "check_t0", [5]), 1);

// table_copy.wast:420
assert_trap(() => call($6, "check_t0", [6]));

// table_copy.wast:421
assert_trap(() => call($6, "check_t0", [7]));

// table_copy.wast:422
assert_trap(() => call($6, "check_t0", [8]));

// table_copy.wast:423
assert_trap(() => call($6, "check_t0", [9]));

// table_copy.wast:424
assert_trap(() => call($6, "check_t0", [10]));

// table_copy.wast:425
assert_trap(() => call($6, "check_t0", [11]));

// table_copy.wast:426
assert_return(() => call($6, "check_t0", [12]), 7);

// table_copy.wast:427
assert_return(() => call($6, "check_t0", [13]), 5);

// table_copy.wast:428
assert_return(() => call($6, "check_t0", [14]), 2);

// table_copy.wast:429
assert_return(() => call($6, "check_t0", [15]), 3);

// table_copy.wast:430
assert_return(() => call($6, "check_t0", [16]), 6);

// table_copy.wast:431
assert_trap(() => call($6, "check_t0", [17]));

// table_copy.wast:432
assert_trap(() => call($6, "check_t0", [18]));

// table_copy.wast:433
assert_trap(() => call($6, "check_t0", [19]));

// table_copy.wast:434
assert_trap(() => call($6, "check_t0", [20]));

// table_copy.wast:435
assert_trap(() => call($6, "check_t0", [21]));

// table_copy.wast:436
assert_trap(() => call($6, "check_t0", [22]));

// table_copy.wast:437
assert_trap(() => call($6, "check_t0", [23]));

// table_copy.wast:438
assert_trap(() => call($6, "check_t0", [24]));

// table_copy.wast:439
assert_trap(() => call($6, "check_t0", [25]));

// table_copy.wast:440
assert_trap(() => call($6, "check_t0", [26]));

// table_copy.wast:441
assert_trap(() => call($6, "check_t0", [27]));

// table_copy.wast:442
assert_trap(() => call($6, "check_t0", [28]));

// table_copy.wast:443
assert_trap(() => call($6, "check_t0", [29]));

// table_copy.wast:444
assert_trap(() => call($6, "check_t1", [0]));

// table_copy.wast:445
assert_trap(() => call($6, "check_t1", [1]));

// table_copy.wast:446
assert_trap(() => call($6, "check_t1", [2]));

// table_copy.wast:447
assert_return(() => call($6, "check_t1", [3]), 1);

// table_copy.wast:448
assert_return(() => call($6, "check_t1", [4]), 3);

// table_copy.wast:449
assert_return(() => call($6, "check_t1", [5]), 1);

// table_copy.wast:450
assert_return(() => call($6, "check_t1", [6]), 4);

// table_copy.wast:451
assert_trap(() => call($6, "check_t1", [7]));

// table_copy.wast:452
assert_trap(() => call($6, "check_t1", [8]));

// table_copy.wast:453
assert_trap(() => call($6, "check_t1", [9]));

// table_copy.wast:454
assert_trap(() => call($6, "check_t1", [10]));

// table_copy.wast:455
assert_return(() => call($6, "check_t1", [11]), 6);

// table_copy.wast:456
assert_return(() => call($6, "check_t1", [12]), 3);

// table_copy.wast:457
assert_return(() => call($6, "check_t1", [13]), 2);

// table_copy.wast:458
assert_return(() => call($6, "check_t1", [14]), 5);

// table_copy.wast:459
assert_return(() => call($6, "check_t1", [15]), 7);

// table_copy.wast:460
assert_trap(() => call($6, "check_t1", [16]));

// table_copy.wast:461
assert_trap(() => call($6, "check_t1", [17]));

// table_copy.wast:462
assert_trap(() => call($6, "check_t1", [18]));

// table_copy.wast:463
assert_trap(() => call($6, "check_t1", [19]));

// table_copy.wast:464
assert_trap(() => call($6, "check_t1", [20]));

// table_copy.wast:465
assert_trap(() => call($6, "check_t1", [21]));

// table_copy.wast:466
assert_trap(() => call($6, "check_t1", [22]));

// table_copy.wast:467
assert_trap(() => call($6, "check_t1", [23]));

// table_copy.wast:468
assert_trap(() => call($6, "check_t1", [24]));

// table_copy.wast:469
assert_trap(() => call($6, "check_t1", [25]));

// table_copy.wast:470
assert_trap(() => call($6, "check_t1", [26]));

// table_copy.wast:471
assert_trap(() => call($6, "check_t1", [27]));

// table_copy.wast:472
assert_trap(() => call($6, "check_t1", [28]));

// table_copy.wast:473
assert_trap(() => call($6, "check_t1", [29]));

// table_copy.wast:475
let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x01\x41\x03\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:505
run(() => call($7, "test", []));

// table_copy.wast:506
assert_trap(() => call($7, "check_t0", [0]));

// table_copy.wast:507
assert_trap(() => call($7, "check_t0", [1]));

// table_copy.wast:508
assert_return(() => call($7, "check_t0", [2]), 3);

// table_copy.wast:509
assert_return(() => call($7, "check_t0", [3]), 1);

// table_copy.wast:510
assert_return(() => call($7, "check_t0", [4]), 4);

// table_copy.wast:511
assert_return(() => call($7, "check_t0", [5]), 1);

// table_copy.wast:512
assert_trap(() => call($7, "check_t0", [6]));

// table_copy.wast:513
assert_trap(() => call($7, "check_t0", [7]));

// table_copy.wast:514
assert_trap(() => call($7, "check_t0", [8]));

// table_copy.wast:515
assert_trap(() => call($7, "check_t0", [9]));

// table_copy.wast:516
assert_trap(() => call($7, "check_t0", [10]));

// table_copy.wast:517
assert_trap(() => call($7, "check_t0", [11]));

// table_copy.wast:518
assert_return(() => call($7, "check_t0", [12]), 7);

// table_copy.wast:519
assert_return(() => call($7, "check_t0", [13]), 5);

// table_copy.wast:520
assert_return(() => call($7, "check_t0", [14]), 2);

// table_copy.wast:521
assert_return(() => call($7, "check_t0", [15]), 3);

// table_copy.wast:522
assert_return(() => call($7, "check_t0", [16]), 6);

// table_copy.wast:523
assert_trap(() => call($7, "check_t0", [17]));

// table_copy.wast:524
assert_trap(() => call($7, "check_t0", [18]));

// table_copy.wast:525
assert_trap(() => call($7, "check_t0", [19]));

// table_copy.wast:526
assert_trap(() => call($7, "check_t0", [20]));

// table_copy.wast:527
assert_trap(() => call($7, "check_t0", [21]));

// table_copy.wast:528
assert_trap(() => call($7, "check_t0", [22]));

// table_copy.wast:529
assert_trap(() => call($7, "check_t0", [23]));

// table_copy.wast:530
assert_trap(() => call($7, "check_t0", [24]));

// table_copy.wast:531
assert_trap(() => call($7, "check_t0", [25]));

// table_copy.wast:532
assert_return(() => call($7, "check_t0", [26]), 3);

// table_copy.wast:533
assert_return(() => call($7, "check_t0", [27]), 1);

// table_copy.wast:534
assert_trap(() => call($7, "check_t0", [28]));

// table_copy.wast:535
assert_trap(() => call($7, "check_t0", [29]));

// table_copy.wast:536
assert_trap(() => call($7, "check_t1", [0]));

// table_copy.wast:537
assert_trap(() => call($7, "check_t1", [1]));

// table_copy.wast:538
assert_trap(() => call($7, "check_t1", [2]));

// table_copy.wast:539
assert_return(() => call($7, "check_t1", [3]), 1);

// table_copy.wast:540
assert_return(() => call($7, "check_t1", [4]), 3);

// table_copy.wast:541
assert_return(() => call($7, "check_t1", [5]), 1);

// table_copy.wast:542
assert_return(() => call($7, "check_t1", [6]), 4);

// table_copy.wast:543
assert_trap(() => call($7, "check_t1", [7]));

// table_copy.wast:544
assert_trap(() => call($7, "check_t1", [8]));

// table_copy.wast:545
assert_trap(() => call($7, "check_t1", [9]));

// table_copy.wast:546
assert_trap(() => call($7, "check_t1", [10]));

// table_copy.wast:547
assert_return(() => call($7, "check_t1", [11]), 6);

// table_copy.wast:548
assert_return(() => call($7, "check_t1", [12]), 3);

// table_copy.wast:549
assert_return(() => call($7, "check_t1", [13]), 2);

// table_copy.wast:550
assert_return(() => call($7, "check_t1", [14]), 5);

// table_copy.wast:551
assert_return(() => call($7, "check_t1", [15]), 7);

// table_copy.wast:552
assert_trap(() => call($7, "check_t1", [16]));

// table_copy.wast:553
assert_trap(() => call($7, "check_t1", [17]));

// table_copy.wast:554
assert_trap(() => call($7, "check_t1", [18]));

// table_copy.wast:555
assert_trap(() => call($7, "check_t1", [19]));

// table_copy.wast:556
assert_trap(() => call($7, "check_t1", [20]));

// table_copy.wast:557
assert_trap(() => call($7, "check_t1", [21]));

// table_copy.wast:558
assert_trap(() => call($7, "check_t1", [22]));

// table_copy.wast:559
assert_trap(() => call($7, "check_t1", [23]));

// table_copy.wast:560
assert_trap(() => call($7, "check_t1", [24]));

// table_copy.wast:561
assert_trap(() => call($7, "check_t1", [25]));

// table_copy.wast:562
assert_trap(() => call($7, "check_t1", [26]));

// table_copy.wast:563
assert_trap(() => call($7, "check_t1", [27]));

// table_copy.wast:564
assert_trap(() => call($7, "check_t1", [28]));

// table_copy.wast:565
assert_trap(() => call($7, "check_t1", [29]));

// table_copy.wast:567
let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x0c\x41\x07\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:597
run(() => call($8, "test", []));

// table_copy.wast:598
assert_trap(() => call($8, "check_t0", [0]));

// table_copy.wast:599
assert_trap(() => call($8, "check_t0", [1]));

// table_copy.wast:600
assert_return(() => call($8, "check_t0", [2]), 3);

// table_copy.wast:601
assert_return(() => call($8, "check_t0", [3]), 1);

// table_copy.wast:602
assert_return(() => call($8, "check_t0", [4]), 4);

// table_copy.wast:603
assert_return(() => call($8, "check_t0", [5]), 1);

// table_copy.wast:604
assert_trap(() => call($8, "check_t0", [6]));

// table_copy.wast:605
assert_trap(() => call($8, "check_t0", [7]));

// table_copy.wast:606
assert_trap(() => call($8, "check_t0", [8]));

// table_copy.wast:607
assert_trap(() => call($8, "check_t0", [9]));

// table_copy.wast:608
assert_return(() => call($8, "check_t0", [10]), 7);

// table_copy.wast:609
assert_return(() => call($8, "check_t0", [11]), 5);

// table_copy.wast:610
assert_return(() => call($8, "check_t0", [12]), 2);

// table_copy.wast:611
assert_return(() => call($8, "check_t0", [13]), 3);

// table_copy.wast:612
assert_return(() => call($8, "check_t0", [14]), 6);

// table_copy.wast:613
assert_trap(() => call($8, "check_t0", [15]));

// table_copy.wast:614
assert_trap(() => call($8, "check_t0", [16]));

// table_copy.wast:615
assert_trap(() => call($8, "check_t0", [17]));

// table_copy.wast:616
assert_trap(() => call($8, "check_t0", [18]));

// table_copy.wast:617
assert_trap(() => call($8, "check_t0", [19]));

// table_copy.wast:618
assert_trap(() => call($8, "check_t0", [20]));

// table_copy.wast:619
assert_trap(() => call($8, "check_t0", [21]));

// table_copy.wast:620
assert_trap(() => call($8, "check_t0", [22]));

// table_copy.wast:621
assert_trap(() => call($8, "check_t0", [23]));

// table_copy.wast:622
assert_trap(() => call($8, "check_t0", [24]));

// table_copy.wast:623
assert_trap(() => call($8, "check_t0", [25]));

// table_copy.wast:624
assert_trap(() => call($8, "check_t0", [26]));

// table_copy.wast:625
assert_trap(() => call($8, "check_t0", [27]));

// table_copy.wast:626
assert_trap(() => call($8, "check_t0", [28]));

// table_copy.wast:627
assert_trap(() => call($8, "check_t0", [29]));

// table_copy.wast:628
assert_trap(() => call($8, "check_t1", [0]));

// table_copy.wast:629
assert_trap(() => call($8, "check_t1", [1]));

// table_copy.wast:630
assert_trap(() => call($8, "check_t1", [2]));

// table_copy.wast:631
assert_return(() => call($8, "check_t1", [3]), 1);

// table_copy.wast:632
assert_return(() => call($8, "check_t1", [4]), 3);

// table_copy.wast:633
assert_return(() => call($8, "check_t1", [5]), 1);

// table_copy.wast:634
assert_return(() => call($8, "check_t1", [6]), 4);

// table_copy.wast:635
assert_trap(() => call($8, "check_t1", [7]));

// table_copy.wast:636
assert_trap(() => call($8, "check_t1", [8]));

// table_copy.wast:637
assert_trap(() => call($8, "check_t1", [9]));

// table_copy.wast:638
assert_trap(() => call($8, "check_t1", [10]));

// table_copy.wast:639
assert_return(() => call($8, "check_t1", [11]), 6);

// table_copy.wast:640
assert_return(() => call($8, "check_t1", [12]), 3);

// table_copy.wast:641
assert_return(() => call($8, "check_t1", [13]), 2);

// table_copy.wast:642
assert_return(() => call($8, "check_t1", [14]), 5);

// table_copy.wast:643
assert_return(() => call($8, "check_t1", [15]), 7);

// table_copy.wast:644
assert_trap(() => call($8, "check_t1", [16]));

// table_copy.wast:645
assert_trap(() => call($8, "check_t1", [17]));

// table_copy.wast:646
assert_trap(() => call($8, "check_t1", [18]));

// table_copy.wast:647
assert_trap(() => call($8, "check_t1", [19]));

// table_copy.wast:648
assert_trap(() => call($8, "check_t1", [20]));

// table_copy.wast:649
assert_trap(() => call($8, "check_t1", [21]));

// table_copy.wast:650
assert_trap(() => call($8, "check_t1", [22]));

// table_copy.wast:651
assert_trap(() => call($8, "check_t1", [23]));

// table_copy.wast:652
assert_trap(() => call($8, "check_t1", [24]));

// table_copy.wast:653
assert_trap(() => call($8, "check_t1", [25]));

// table_copy.wast:654
assert_trap(() => call($8, "check_t1", [26]));

// table_copy.wast:655
assert_trap(() => call($8, "check_t1", [27]));

// table_copy.wast:656
assert_trap(() => call($8, "check_t1", [28]));

// table_copy.wast:657
assert_trap(() => call($8, "check_t1", [29]));

// table_copy.wast:659
let $9 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x0a\x41\x07\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:689
run(() => call($9, "test", []));

// table_copy.wast:690
assert_trap(() => call($9, "check_t0", [0]));

// table_copy.wast:691
assert_trap(() => call($9, "check_t0", [1]));

// table_copy.wast:692
assert_return(() => call($9, "check_t0", [2]), 3);

// table_copy.wast:693
assert_return(() => call($9, "check_t0", [3]), 1);

// table_copy.wast:694
assert_return(() => call($9, "check_t0", [4]), 4);

// table_copy.wast:695
assert_return(() => call($9, "check_t0", [5]), 1);

// table_copy.wast:696
assert_trap(() => call($9, "check_t0", [6]));

// table_copy.wast:697
assert_trap(() => call($9, "check_t0", [7]));

// table_copy.wast:698
assert_trap(() => call($9, "check_t0", [8]));

// table_copy.wast:699
assert_trap(() => call($9, "check_t0", [9]));

// table_copy.wast:700
assert_trap(() => call($9, "check_t0", [10]));

// table_copy.wast:701
assert_trap(() => call($9, "check_t0", [11]));

// table_copy.wast:702
assert_trap(() => call($9, "check_t0", [12]));

// table_copy.wast:703
assert_trap(() => call($9, "check_t0", [13]));

// table_copy.wast:704
assert_return(() => call($9, "check_t0", [14]), 7);

// table_copy.wast:705
assert_return(() => call($9, "check_t0", [15]), 5);

// table_copy.wast:706
assert_return(() => call($9, "check_t0", [16]), 2);

// table_copy.wast:707
assert_return(() => call($9, "check_t0", [17]), 3);

// table_copy.wast:708
assert_return(() => call($9, "check_t0", [18]), 6);

// table_copy.wast:709
assert_trap(() => call($9, "check_t0", [19]));

// table_copy.wast:710
assert_trap(() => call($9, "check_t0", [20]));

// table_copy.wast:711
assert_trap(() => call($9, "check_t0", [21]));

// table_copy.wast:712
assert_trap(() => call($9, "check_t0", [22]));

// table_copy.wast:713
assert_trap(() => call($9, "check_t0", [23]));

// table_copy.wast:714
assert_trap(() => call($9, "check_t0", [24]));

// table_copy.wast:715
assert_trap(() => call($9, "check_t0", [25]));

// table_copy.wast:716
assert_trap(() => call($9, "check_t0", [26]));

// table_copy.wast:717
assert_trap(() => call($9, "check_t0", [27]));

// table_copy.wast:718
assert_trap(() => call($9, "check_t0", [28]));

// table_copy.wast:719
assert_trap(() => call($9, "check_t0", [29]));

// table_copy.wast:720
assert_trap(() => call($9, "check_t1", [0]));

// table_copy.wast:721
assert_trap(() => call($9, "check_t1", [1]));

// table_copy.wast:722
assert_trap(() => call($9, "check_t1", [2]));

// table_copy.wast:723
assert_return(() => call($9, "check_t1", [3]), 1);

// table_copy.wast:724
assert_return(() => call($9, "check_t1", [4]), 3);

// table_copy.wast:725
assert_return(() => call($9, "check_t1", [5]), 1);

// table_copy.wast:726
assert_return(() => call($9, "check_t1", [6]), 4);

// table_copy.wast:727
assert_trap(() => call($9, "check_t1", [7]));

// table_copy.wast:728
assert_trap(() => call($9, "check_t1", [8]));

// table_copy.wast:729
assert_trap(() => call($9, "check_t1", [9]));

// table_copy.wast:730
assert_trap(() => call($9, "check_t1", [10]));

// table_copy.wast:731
assert_return(() => call($9, "check_t1", [11]), 6);

// table_copy.wast:732
assert_return(() => call($9, "check_t1", [12]), 3);

// table_copy.wast:733
assert_return(() => call($9, "check_t1", [13]), 2);

// table_copy.wast:734
assert_return(() => call($9, "check_t1", [14]), 5);

// table_copy.wast:735
assert_return(() => call($9, "check_t1", [15]), 7);

// table_copy.wast:736
assert_trap(() => call($9, "check_t1", [16]));

// table_copy.wast:737
assert_trap(() => call($9, "check_t1", [17]));

// table_copy.wast:738
assert_trap(() => call($9, "check_t1", [18]));

// table_copy.wast:739
assert_trap(() => call($9, "check_t1", [19]));

// table_copy.wast:740
assert_trap(() => call($9, "check_t1", [20]));

// table_copy.wast:741
assert_trap(() => call($9, "check_t1", [21]));

// table_copy.wast:742
assert_trap(() => call($9, "check_t1", [22]));

// table_copy.wast:743
assert_trap(() => call($9, "check_t1", [23]));

// table_copy.wast:744
assert_trap(() => call($9, "check_t1", [24]));

// table_copy.wast:745
assert_trap(() => call($9, "check_t1", [25]));

// table_copy.wast:746
assert_trap(() => call($9, "check_t1", [26]));

// table_copy.wast:747
assert_trap(() => call($9, "check_t1", [27]));

// table_copy.wast:748
assert_trap(() => call($9, "check_t1", [28]));

// table_copy.wast:749
assert_trap(() => call($9, "check_t1", [29]));

// table_copy.wast:751
let $10 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x02\x01\x41\x03\x0b\x00\x04\x01\x03\x01\x04\x02\x01\x41\x0b\x0b\x00\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x00\x41\x14\xfc\x0e\x01\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_copy.wast:781
run(() => call($10, "test", []));

// table_copy.wast:782
assert_trap(() => call($10, "check_t0", [0]));

// table_copy.wast:783
assert_trap(() => call($10, "check_t0", [1]));

// table_copy.wast:784
assert_return(() => call($10, "check_t0", [2]), 3);

// table_copy.wast:785
assert_return(() => call($10, "check_t0", [3]), 1);

// table_copy.wast:786
assert_return(() => call($10, "check_t0", [4]), 4);

// table_copy.wast:787
assert_return(() => call($10, "check_t0", [5]), 1);

// table_copy.wast:788
assert_trap(() => call($10, "check_t0", [6]));

// table_copy.wast:789
assert_trap(() => call($10, "check_t0", [7]));

// table_copy.wast:790
assert_trap(() => call($10, "check_t0", [8]));

// table_copy.wast:791
assert_trap(() => call($10, "check_t0", [9]));

// table_copy.wast:792
assert_trap(() => call($10, "check_t0", [10]));

// table_copy.wast:793
assert_trap(() => call($10, "check_t0", [11]));

// table_copy.wast:794
assert_return(() => call($10, "check_t0", [12]), 7);

// table_copy.wast:795
assert_return(() => call($10, "check_t0", [13]), 5);

// table_copy.wast:796
assert_return(() => call($10, "check_t0", [14]), 2);

// table_copy.wast:797
assert_return(() => call($10, "check_t0", [15]), 3);

// table_copy.wast:798
assert_return(() => call($10, "check_t0", [16]), 6);

// table_copy.wast:799
assert_trap(() => call($10, "check_t0", [17]));

// table_copy.wast:800
assert_trap(() => call($10, "check_t0", [18]));

// table_copy.wast:801
assert_trap(() => call($10, "check_t0", [19]));

// table_copy.wast:802
assert_trap(() => call($10, "check_t0", [20]));

// table_copy.wast:803
assert_trap(() => call($10, "check_t0", [21]));

// table_copy.wast:804
assert_trap(() => call($10, "check_t0", [22]));

// table_copy.wast:805
assert_trap(() => call($10, "check_t0", [23]));

// table_copy.wast:806
assert_trap(() => call($10, "check_t0", [24]));

// table_copy.wast:807
assert_trap(() => call($10, "check_t0", [25]));

// table_copy.wast:808
assert_trap(() => call($10, "check_t0", [26]));

// table_copy.wast:809
assert_trap(() => call($10, "check_t0", [27]));

// table_copy.wast:810
assert_trap(() => call($10, "check_t0", [28]));

// table_copy.wast:811
assert_trap(() => call($10, "check_t0", [29]));

// table_copy.wast:812
assert_trap(() => call($10, "check_t1", [0]));

// table_copy.wast:813
assert_trap(() => call($10, "check_t1", [1]));

// table_copy.wast:814
assert_trap(() => call($10, "check_t1", [2]));

// table_copy.wast:815
assert_return(() => call($10, "check_t1", [3]), 1);

// table_copy.wast:816
assert_return(() => call($10, "check_t1", [4]), 3);

// table_copy.wast:817
assert_return(() => call($10, "check_t1", [5]), 1);

// table_copy.wast:818
assert_return(() => call($10, "check_t1", [6]), 4);

// table_copy.wast:819
assert_trap(() => call($10, "check_t1", [7]));

// table_copy.wast:820
assert_trap(() => call($10, "check_t1", [8]));

// table_copy.wast:821
assert_trap(() => call($10, "check_t1", [9]));

// table_copy.wast:822
assert_trap(() => call($10, "check_t1", [10]));

// table_copy.wast:823
assert_trap(() => call($10, "check_t1", [11]));

// table_copy.wast:824
assert_return(() => call($10, "check_t1", [12]), 3);

// table_copy.wast:825
assert_return(() => call($10, "check_t1", [13]), 1);

// table_copy.wast:826
assert_return(() => call($10, "check_t1", [14]), 4);

// table_copy.wast:827
assert_return(() => call($10, "check_t1", [15]), 1);

// table_copy.wast:828
assert_trap(() => call($10, "check_t1", [16]));

// table_copy.wast:829
assert_trap(() => call($10, "check_t1", [17]));

// table_copy.wast:830
assert_trap(() => call($10, "check_t1", [18]));

// table_copy.wast:831
assert_trap(() => call($10, "check_t1", [19]));

// table_copy.wast:832
assert_trap(() => call($10, "check_t1", [20]));

// table_copy.wast:833
assert_trap(() => call($10, "check_t1", [21]));

// table_copy.wast:834
assert_return(() => call($10, "check_t1", [22]), 7);

// table_copy.wast:835
assert_return(() => call($10, "check_t1", [23]), 5);

// table_copy.wast:836
assert_return(() => call($10, "check_t1", [24]), 2);

// table_copy.wast:837
assert_return(() => call($10, "check_t1", [25]), 3);

// table_copy.wast:838
assert_return(() => call($10, "check_t1", [26]), 6);

// table_copy.wast:839
assert_trap(() => call($10, "check_t1", [27]));

// table_copy.wast:840
assert_trap(() => call($10, "check_t1", [28]));

// table_copy.wast:841
assert_trap(() => call($10, "check_t1", [29]));

// table_copy.wast:843
let $11 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xce\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x83\x80\x80\x80\x00\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:873
run(() => call($11, "test", []));

// table_copy.wast:874
assert_trap(() => call($11, "check_t0", [0]));

// table_copy.wast:875
assert_trap(() => call($11, "check_t0", [1]));

// table_copy.wast:876
assert_return(() => call($11, "check_t0", [2]), 3);

// table_copy.wast:877
assert_return(() => call($11, "check_t0", [3]), 1);

// table_copy.wast:878
assert_return(() => call($11, "check_t0", [4]), 4);

// table_copy.wast:879
assert_return(() => call($11, "check_t0", [5]), 1);

// table_copy.wast:880
assert_trap(() => call($11, "check_t0", [6]));

// table_copy.wast:881
assert_trap(() => call($11, "check_t0", [7]));

// table_copy.wast:882
assert_trap(() => call($11, "check_t0", [8]));

// table_copy.wast:883
assert_trap(() => call($11, "check_t0", [9]));

// table_copy.wast:884
assert_trap(() => call($11, "check_t0", [10]));

// table_copy.wast:885
assert_trap(() => call($11, "check_t0", [11]));

// table_copy.wast:886
assert_return(() => call($11, "check_t0", [12]), 7);

// table_copy.wast:887
assert_return(() => call($11, "check_t0", [13]), 5);

// table_copy.wast:888
assert_return(() => call($11, "check_t0", [14]), 2);

// table_copy.wast:889
assert_return(() => call($11, "check_t0", [15]), 3);

// table_copy.wast:890
assert_return(() => call($11, "check_t0", [16]), 6);

// table_copy.wast:891
assert_trap(() => call($11, "check_t0", [17]));

// table_copy.wast:892
assert_trap(() => call($11, "check_t0", [18]));

// table_copy.wast:893
assert_trap(() => call($11, "check_t0", [19]));

// table_copy.wast:894
assert_trap(() => call($11, "check_t0", [20]));

// table_copy.wast:895
assert_trap(() => call($11, "check_t0", [21]));

// table_copy.wast:896
assert_trap(() => call($11, "check_t0", [22]));

// table_copy.wast:897
assert_trap(() => call($11, "check_t0", [23]));

// table_copy.wast:898
assert_trap(() => call($11, "check_t0", [24]));

// table_copy.wast:899
assert_trap(() => call($11, "check_t0", [25]));

// table_copy.wast:900
assert_trap(() => call($11, "check_t0", [26]));

// table_copy.wast:901
assert_trap(() => call($11, "check_t0", [27]));

// table_copy.wast:902
assert_trap(() => call($11, "check_t0", [28]));

// table_copy.wast:903
assert_trap(() => call($11, "check_t0", [29]));

// table_copy.wast:904
assert_trap(() => call($11, "check_t1", [0]));

// table_copy.wast:905
assert_trap(() => call($11, "check_t1", [1]));

// table_copy.wast:906
assert_trap(() => call($11, "check_t1", [2]));

// table_copy.wast:907
assert_return(() => call($11, "check_t1", [3]), 1);

// table_copy.wast:908
assert_return(() => call($11, "check_t1", [4]), 3);

// table_copy.wast:909
assert_return(() => call($11, "check_t1", [5]), 1);

// table_copy.wast:910
assert_return(() => call($11, "check_t1", [6]), 4);

// table_copy.wast:911
assert_trap(() => call($11, "check_t1", [7]));

// table_copy.wast:912
assert_trap(() => call($11, "check_t1", [8]));

// table_copy.wast:913
assert_trap(() => call($11, "check_t1", [9]));

// table_copy.wast:914
assert_trap(() => call($11, "check_t1", [10]));

// table_copy.wast:915
assert_return(() => call($11, "check_t1", [11]), 6);

// table_copy.wast:916
assert_return(() => call($11, "check_t1", [12]), 3);

// table_copy.wast:917
assert_return(() => call($11, "check_t1", [13]), 2);

// table_copy.wast:918
assert_return(() => call($11, "check_t1", [14]), 5);

// table_copy.wast:919
assert_return(() => call($11, "check_t1", [15]), 7);

// table_copy.wast:920
assert_trap(() => call($11, "check_t1", [16]));

// table_copy.wast:921
assert_trap(() => call($11, "check_t1", [17]));

// table_copy.wast:922
assert_trap(() => call($11, "check_t1", [18]));

// table_copy.wast:923
assert_trap(() => call($11, "check_t1", [19]));

// table_copy.wast:924
assert_trap(() => call($11, "check_t1", [20]));

// table_copy.wast:925
assert_trap(() => call($11, "check_t1", [21]));

// table_copy.wast:926
assert_trap(() => call($11, "check_t1", [22]));

// table_copy.wast:927
assert_trap(() => call($11, "check_t1", [23]));

// table_copy.wast:928
assert_trap(() => call($11, "check_t1", [24]));

// table_copy.wast:929
assert_trap(() => call($11, "check_t1", [25]));

// table_copy.wast:930
assert_trap(() => call($11, "check_t1", [26]));

// table_copy.wast:931
assert_trap(() => call($11, "check_t1", [27]));

// table_copy.wast:932
assert_trap(() => call($11, "check_t1", [28]));

// table_copy.wast:933
assert_trap(() => call($11, "check_t1", [29]));

// table_copy.wast:935
let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x02\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:965
run(() => call($12, "test", []));

// table_copy.wast:966
assert_trap(() => call($12, "check_t0", [0]));

// table_copy.wast:967
assert_trap(() => call($12, "check_t0", [1]));

// table_copy.wast:968
assert_return(() => call($12, "check_t0", [2]), 3);

// table_copy.wast:969
assert_return(() => call($12, "check_t0", [3]), 1);

// table_copy.wast:970
assert_return(() => call($12, "check_t0", [4]), 4);

// table_copy.wast:971
assert_return(() => call($12, "check_t0", [5]), 1);

// table_copy.wast:972
assert_trap(() => call($12, "check_t0", [6]));

// table_copy.wast:973
assert_trap(() => call($12, "check_t0", [7]));

// table_copy.wast:974
assert_trap(() => call($12, "check_t0", [8]));

// table_copy.wast:975
assert_trap(() => call($12, "check_t0", [9]));

// table_copy.wast:976
assert_trap(() => call($12, "check_t0", [10]));

// table_copy.wast:977
assert_trap(() => call($12, "check_t0", [11]));

// table_copy.wast:978
assert_return(() => call($12, "check_t0", [12]), 7);

// table_copy.wast:979
assert_return(() => call($12, "check_t0", [13]), 3);

// table_copy.wast:980
assert_return(() => call($12, "check_t0", [14]), 1);

// table_copy.wast:981
assert_return(() => call($12, "check_t0", [15]), 4);

// table_copy.wast:982
assert_return(() => call($12, "check_t0", [16]), 6);

// table_copy.wast:983
assert_trap(() => call($12, "check_t0", [17]));

// table_copy.wast:984
assert_trap(() => call($12, "check_t0", [18]));

// table_copy.wast:985
assert_trap(() => call($12, "check_t0", [19]));

// table_copy.wast:986
assert_trap(() => call($12, "check_t0", [20]));

// table_copy.wast:987
assert_trap(() => call($12, "check_t0", [21]));

// table_copy.wast:988
assert_trap(() => call($12, "check_t0", [22]));

// table_copy.wast:989
assert_trap(() => call($12, "check_t0", [23]));

// table_copy.wast:990
assert_trap(() => call($12, "check_t0", [24]));

// table_copy.wast:991
assert_trap(() => call($12, "check_t0", [25]));

// table_copy.wast:992
assert_trap(() => call($12, "check_t0", [26]));

// table_copy.wast:993
assert_trap(() => call($12, "check_t0", [27]));

// table_copy.wast:994
assert_trap(() => call($12, "check_t0", [28]));

// table_copy.wast:995
assert_trap(() => call($12, "check_t0", [29]));

// table_copy.wast:996
assert_trap(() => call($12, "check_t1", [0]));

// table_copy.wast:997
assert_trap(() => call($12, "check_t1", [1]));

// table_copy.wast:998
assert_trap(() => call($12, "check_t1", [2]));

// table_copy.wast:999
assert_return(() => call($12, "check_t1", [3]), 1);

// table_copy.wast:1000
assert_return(() => call($12, "check_t1", [4]), 3);

// table_copy.wast:1001
assert_return(() => call($12, "check_t1", [5]), 1);

// table_copy.wast:1002
assert_return(() => call($12, "check_t1", [6]), 4);

// table_copy.wast:1003
assert_trap(() => call($12, "check_t1", [7]));

// table_copy.wast:1004
assert_trap(() => call($12, "check_t1", [8]));

// table_copy.wast:1005
assert_trap(() => call($12, "check_t1", [9]));

// table_copy.wast:1006
assert_trap(() => call($12, "check_t1", [10]));

// table_copy.wast:1007
assert_return(() => call($12, "check_t1", [11]), 6);

// table_copy.wast:1008
assert_return(() => call($12, "check_t1", [12]), 3);

// table_copy.wast:1009
assert_return(() => call($12, "check_t1", [13]), 2);

// table_copy.wast:1010
assert_return(() => call($12, "check_t1", [14]), 5);

// table_copy.wast:1011
assert_return(() => call($12, "check_t1", [15]), 7);

// table_copy.wast:1012
assert_trap(() => call($12, "check_t1", [16]));

// table_copy.wast:1013
assert_trap(() => call($12, "check_t1", [17]));

// table_copy.wast:1014
assert_trap(() => call($12, "check_t1", [18]));

// table_copy.wast:1015
assert_trap(() => call($12, "check_t1", [19]));

// table_copy.wast:1016
assert_trap(() => call($12, "check_t1", [20]));

// table_copy.wast:1017
assert_trap(() => call($12, "check_t1", [21]));

// table_copy.wast:1018
assert_trap(() => call($12, "check_t1", [22]));

// table_copy.wast:1019
assert_trap(() => call($12, "check_t1", [23]));

// table_copy.wast:1020
assert_trap(() => call($12, "check_t1", [24]));

// table_copy.wast:1021
assert_trap(() => call($12, "check_t1", [25]));

// table_copy.wast:1022
assert_trap(() => call($12, "check_t1", [26]));

// table_copy.wast:1023
assert_trap(() => call($12, "check_t1", [27]));

// table_copy.wast:1024
assert_trap(() => call($12, "check_t1", [28]));

// table_copy.wast:1025
assert_trap(() => call($12, "check_t1", [29]));

// table_copy.wast:1027
let $13 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x0f\x41\x02\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1057
run(() => call($13, "test", []));

// table_copy.wast:1058
assert_trap(() => call($13, "check_t0", [0]));

// table_copy.wast:1059
assert_trap(() => call($13, "check_t0", [1]));

// table_copy.wast:1060
assert_return(() => call($13, "check_t0", [2]), 3);

// table_copy.wast:1061
assert_return(() => call($13, "check_t0", [3]), 1);

// table_copy.wast:1062
assert_return(() => call($13, "check_t0", [4]), 4);

// table_copy.wast:1063
assert_return(() => call($13, "check_t0", [5]), 1);

// table_copy.wast:1064
assert_trap(() => call($13, "check_t0", [6]));

// table_copy.wast:1065
assert_trap(() => call($13, "check_t0", [7]));

// table_copy.wast:1066
assert_trap(() => call($13, "check_t0", [8]));

// table_copy.wast:1067
assert_trap(() => call($13, "check_t0", [9]));

// table_copy.wast:1068
assert_trap(() => call($13, "check_t0", [10]));

// table_copy.wast:1069
assert_trap(() => call($13, "check_t0", [11]));

// table_copy.wast:1070
assert_return(() => call($13, "check_t0", [12]), 7);

// table_copy.wast:1071
assert_return(() => call($13, "check_t0", [13]), 5);

// table_copy.wast:1072
assert_return(() => call($13, "check_t0", [14]), 2);

// table_copy.wast:1073
assert_return(() => call($13, "check_t0", [15]), 3);

// table_copy.wast:1074
assert_return(() => call($13, "check_t0", [16]), 6);

// table_copy.wast:1075
assert_trap(() => call($13, "check_t0", [17]));

// table_copy.wast:1076
assert_trap(() => call($13, "check_t0", [18]));

// table_copy.wast:1077
assert_trap(() => call($13, "check_t0", [19]));

// table_copy.wast:1078
assert_trap(() => call($13, "check_t0", [20]));

// table_copy.wast:1079
assert_trap(() => call($13, "check_t0", [21]));

// table_copy.wast:1080
assert_trap(() => call($13, "check_t0", [22]));

// table_copy.wast:1081
assert_trap(() => call($13, "check_t0", [23]));

// table_copy.wast:1082
assert_trap(() => call($13, "check_t0", [24]));

// table_copy.wast:1083
assert_return(() => call($13, "check_t0", [25]), 3);

// table_copy.wast:1084
assert_return(() => call($13, "check_t0", [26]), 6);

// table_copy.wast:1085
assert_trap(() => call($13, "check_t0", [27]));

// table_copy.wast:1086
assert_trap(() => call($13, "check_t0", [28]));

// table_copy.wast:1087
assert_trap(() => call($13, "check_t0", [29]));

// table_copy.wast:1088
assert_trap(() => call($13, "check_t1", [0]));

// table_copy.wast:1089
assert_trap(() => call($13, "check_t1", [1]));

// table_copy.wast:1090
assert_trap(() => call($13, "check_t1", [2]));

// table_copy.wast:1091
assert_return(() => call($13, "check_t1", [3]), 1);

// table_copy.wast:1092
assert_return(() => call($13, "check_t1", [4]), 3);

// table_copy.wast:1093
assert_return(() => call($13, "check_t1", [5]), 1);

// table_copy.wast:1094
assert_return(() => call($13, "check_t1", [6]), 4);

// table_copy.wast:1095
assert_trap(() => call($13, "check_t1", [7]));

// table_copy.wast:1096
assert_trap(() => call($13, "check_t1", [8]));

// table_copy.wast:1097
assert_trap(() => call($13, "check_t1", [9]));

// table_copy.wast:1098
assert_trap(() => call($13, "check_t1", [10]));

// table_copy.wast:1099
assert_return(() => call($13, "check_t1", [11]), 6);

// table_copy.wast:1100
assert_return(() => call($13, "check_t1", [12]), 3);

// table_copy.wast:1101
assert_return(() => call($13, "check_t1", [13]), 2);

// table_copy.wast:1102
assert_return(() => call($13, "check_t1", [14]), 5);

// table_copy.wast:1103
assert_return(() => call($13, "check_t1", [15]), 7);

// table_copy.wast:1104
assert_trap(() => call($13, "check_t1", [16]));

// table_copy.wast:1105
assert_trap(() => call($13, "check_t1", [17]));

// table_copy.wast:1106
assert_trap(() => call($13, "check_t1", [18]));

// table_copy.wast:1107
assert_trap(() => call($13, "check_t1", [19]));

// table_copy.wast:1108
assert_trap(() => call($13, "check_t1", [20]));

// table_copy.wast:1109
assert_trap(() => call($13, "check_t1", [21]));

// table_copy.wast:1110
assert_trap(() => call($13, "check_t1", [22]));

// table_copy.wast:1111
assert_trap(() => call($13, "check_t1", [23]));

// table_copy.wast:1112
assert_trap(() => call($13, "check_t1", [24]));

// table_copy.wast:1113
assert_trap(() => call($13, "check_t1", [25]));

// table_copy.wast:1114
assert_trap(() => call($13, "check_t1", [26]));

// table_copy.wast:1115
assert_trap(() => call($13, "check_t1", [27]));

// table_copy.wast:1116
assert_trap(() => call($13, "check_t1", [28]));

// table_copy.wast:1117
assert_trap(() => call($13, "check_t1", [29]));

// table_copy.wast:1119
let $14 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0d\x41\x19\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1149
run(() => call($14, "test", []));

// table_copy.wast:1150
assert_trap(() => call($14, "check_t0", [0]));

// table_copy.wast:1151
assert_trap(() => call($14, "check_t0", [1]));

// table_copy.wast:1152
assert_return(() => call($14, "check_t0", [2]), 3);

// table_copy.wast:1153
assert_return(() => call($14, "check_t0", [3]), 1);

// table_copy.wast:1154
assert_return(() => call($14, "check_t0", [4]), 4);

// table_copy.wast:1155
assert_return(() => call($14, "check_t0", [5]), 1);

// table_copy.wast:1156
assert_trap(() => call($14, "check_t0", [6]));

// table_copy.wast:1157
assert_trap(() => call($14, "check_t0", [7]));

// table_copy.wast:1158
assert_trap(() => call($14, "check_t0", [8]));

// table_copy.wast:1159
assert_trap(() => call($14, "check_t0", [9]));

// table_copy.wast:1160
assert_trap(() => call($14, "check_t0", [10]));

// table_copy.wast:1161
assert_trap(() => call($14, "check_t0", [11]));

// table_copy.wast:1162
assert_return(() => call($14, "check_t0", [12]), 7);

// table_copy.wast:1163
assert_trap(() => call($14, "check_t0", [13]));

// table_copy.wast:1164
assert_trap(() => call($14, "check_t0", [14]));

// table_copy.wast:1165
assert_trap(() => call($14, "check_t0", [15]));

// table_copy.wast:1166
assert_return(() => call($14, "check_t0", [16]), 6);

// table_copy.wast:1167
assert_trap(() => call($14, "check_t0", [17]));

// table_copy.wast:1168
assert_trap(() => call($14, "check_t0", [18]));

// table_copy.wast:1169
assert_trap(() => call($14, "check_t0", [19]));

// table_copy.wast:1170
assert_trap(() => call($14, "check_t0", [20]));

// table_copy.wast:1171
assert_trap(() => call($14, "check_t0", [21]));

// table_copy.wast:1172
assert_trap(() => call($14, "check_t0", [22]));

// table_copy.wast:1173
assert_trap(() => call($14, "check_t0", [23]));

// table_copy.wast:1174
assert_trap(() => call($14, "check_t0", [24]));

// table_copy.wast:1175
assert_trap(() => call($14, "check_t0", [25]));

// table_copy.wast:1176
assert_trap(() => call($14, "check_t0", [26]));

// table_copy.wast:1177
assert_trap(() => call($14, "check_t0", [27]));

// table_copy.wast:1178
assert_trap(() => call($14, "check_t0", [28]));

// table_copy.wast:1179
assert_trap(() => call($14, "check_t0", [29]));

// table_copy.wast:1180
assert_trap(() => call($14, "check_t1", [0]));

// table_copy.wast:1181
assert_trap(() => call($14, "check_t1", [1]));

// table_copy.wast:1182
assert_trap(() => call($14, "check_t1", [2]));

// table_copy.wast:1183
assert_return(() => call($14, "check_t1", [3]), 1);

// table_copy.wast:1184
assert_return(() => call($14, "check_t1", [4]), 3);

// table_copy.wast:1185
assert_return(() => call($14, "check_t1", [5]), 1);

// table_copy.wast:1186
assert_return(() => call($14, "check_t1", [6]), 4);

// table_copy.wast:1187
assert_trap(() => call($14, "check_t1", [7]));

// table_copy.wast:1188
assert_trap(() => call($14, "check_t1", [8]));

// table_copy.wast:1189
assert_trap(() => call($14, "check_t1", [9]));

// table_copy.wast:1190
assert_trap(() => call($14, "check_t1", [10]));

// table_copy.wast:1191
assert_return(() => call($14, "check_t1", [11]), 6);

// table_copy.wast:1192
assert_return(() => call($14, "check_t1", [12]), 3);

// table_copy.wast:1193
assert_return(() => call($14, "check_t1", [13]), 2);

// table_copy.wast:1194
assert_return(() => call($14, "check_t1", [14]), 5);

// table_copy.wast:1195
assert_return(() => call($14, "check_t1", [15]), 7);

// table_copy.wast:1196
assert_trap(() => call($14, "check_t1", [16]));

// table_copy.wast:1197
assert_trap(() => call($14, "check_t1", [17]));

// table_copy.wast:1198
assert_trap(() => call($14, "check_t1", [18]));

// table_copy.wast:1199
assert_trap(() => call($14, "check_t1", [19]));

// table_copy.wast:1200
assert_trap(() => call($14, "check_t1", [20]));

// table_copy.wast:1201
assert_trap(() => call($14, "check_t1", [21]));

// table_copy.wast:1202
assert_trap(() => call($14, "check_t1", [22]));

// table_copy.wast:1203
assert_trap(() => call($14, "check_t1", [23]));

// table_copy.wast:1204
assert_trap(() => call($14, "check_t1", [24]));

// table_copy.wast:1205
assert_trap(() => call($14, "check_t1", [25]));

// table_copy.wast:1206
assert_trap(() => call($14, "check_t1", [26]));

// table_copy.wast:1207
assert_trap(() => call($14, "check_t1", [27]));

// table_copy.wast:1208
assert_trap(() => call($14, "check_t1", [28]));

// table_copy.wast:1209
assert_trap(() => call($14, "check_t1", [29]));

// table_copy.wast:1211
let $15 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x14\x41\x16\x41\x04\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1241
run(() => call($15, "test", []));

// table_copy.wast:1242
assert_trap(() => call($15, "check_t0", [0]));

// table_copy.wast:1243
assert_trap(() => call($15, "check_t0", [1]));

// table_copy.wast:1244
assert_return(() => call($15, "check_t0", [2]), 3);

// table_copy.wast:1245
assert_return(() => call($15, "check_t0", [3]), 1);

// table_copy.wast:1246
assert_return(() => call($15, "check_t0", [4]), 4);

// table_copy.wast:1247
assert_return(() => call($15, "check_t0", [5]), 1);

// table_copy.wast:1248
assert_trap(() => call($15, "check_t0", [6]));

// table_copy.wast:1249
assert_trap(() => call($15, "check_t0", [7]));

// table_copy.wast:1250
assert_trap(() => call($15, "check_t0", [8]));

// table_copy.wast:1251
assert_trap(() => call($15, "check_t0", [9]));

// table_copy.wast:1252
assert_trap(() => call($15, "check_t0", [10]));

// table_copy.wast:1253
assert_trap(() => call($15, "check_t0", [11]));

// table_copy.wast:1254
assert_return(() => call($15, "check_t0", [12]), 7);

// table_copy.wast:1255
assert_return(() => call($15, "check_t0", [13]), 5);

// table_copy.wast:1256
assert_return(() => call($15, "check_t0", [14]), 2);

// table_copy.wast:1257
assert_return(() => call($15, "check_t0", [15]), 3);

// table_copy.wast:1258
assert_return(() => call($15, "check_t0", [16]), 6);

// table_copy.wast:1259
assert_trap(() => call($15, "check_t0", [17]));

// table_copy.wast:1260
assert_trap(() => call($15, "check_t0", [18]));

// table_copy.wast:1261
assert_trap(() => call($15, "check_t0", [19]));

// table_copy.wast:1262
assert_trap(() => call($15, "check_t0", [20]));

// table_copy.wast:1263
assert_trap(() => call($15, "check_t0", [21]));

// table_copy.wast:1264
assert_trap(() => call($15, "check_t0", [22]));

// table_copy.wast:1265
assert_trap(() => call($15, "check_t0", [23]));

// table_copy.wast:1266
assert_trap(() => call($15, "check_t0", [24]));

// table_copy.wast:1267
assert_trap(() => call($15, "check_t0", [25]));

// table_copy.wast:1268
assert_trap(() => call($15, "check_t0", [26]));

// table_copy.wast:1269
assert_trap(() => call($15, "check_t0", [27]));

// table_copy.wast:1270
assert_trap(() => call($15, "check_t0", [28]));

// table_copy.wast:1271
assert_trap(() => call($15, "check_t0", [29]));

// table_copy.wast:1272
assert_trap(() => call($15, "check_t1", [0]));

// table_copy.wast:1273
assert_trap(() => call($15, "check_t1", [1]));

// table_copy.wast:1274
assert_trap(() => call($15, "check_t1", [2]));

// table_copy.wast:1275
assert_return(() => call($15, "check_t1", [3]), 1);

// table_copy.wast:1276
assert_return(() => call($15, "check_t1", [4]), 3);

// table_copy.wast:1277
assert_return(() => call($15, "check_t1", [5]), 1);

// table_copy.wast:1278
assert_return(() => call($15, "check_t1", [6]), 4);

// table_copy.wast:1279
assert_trap(() => call($15, "check_t1", [7]));

// table_copy.wast:1280
assert_trap(() => call($15, "check_t1", [8]));

// table_copy.wast:1281
assert_trap(() => call($15, "check_t1", [9]));

// table_copy.wast:1282
assert_trap(() => call($15, "check_t1", [10]));

// table_copy.wast:1283
assert_return(() => call($15, "check_t1", [11]), 6);

// table_copy.wast:1284
assert_return(() => call($15, "check_t1", [12]), 3);

// table_copy.wast:1285
assert_return(() => call($15, "check_t1", [13]), 2);

// table_copy.wast:1286
assert_return(() => call($15, "check_t1", [14]), 5);

// table_copy.wast:1287
assert_return(() => call($15, "check_t1", [15]), 7);

// table_copy.wast:1288
assert_trap(() => call($15, "check_t1", [16]));

// table_copy.wast:1289
assert_trap(() => call($15, "check_t1", [17]));

// table_copy.wast:1290
assert_trap(() => call($15, "check_t1", [18]));

// table_copy.wast:1291
assert_trap(() => call($15, "check_t1", [19]));

// table_copy.wast:1292
assert_trap(() => call($15, "check_t1", [20]));

// table_copy.wast:1293
assert_trap(() => call($15, "check_t1", [21]));

// table_copy.wast:1294
assert_trap(() => call($15, "check_t1", [22]));

// table_copy.wast:1295
assert_trap(() => call($15, "check_t1", [23]));

// table_copy.wast:1296
assert_trap(() => call($15, "check_t1", [24]));

// table_copy.wast:1297
assert_trap(() => call($15, "check_t1", [25]));

// table_copy.wast:1298
assert_trap(() => call($15, "check_t1", [26]));

// table_copy.wast:1299
assert_trap(() => call($15, "check_t1", [27]));

// table_copy.wast:1300
assert_trap(() => call($15, "check_t1", [28]));

// table_copy.wast:1301
assert_trap(() => call($15, "check_t1", [29]));

// table_copy.wast:1303
let $16 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x19\x41\x01\x41\x03\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1333
run(() => call($16, "test", []));

// table_copy.wast:1334
assert_trap(() => call($16, "check_t0", [0]));

// table_copy.wast:1335
assert_trap(() => call($16, "check_t0", [1]));

// table_copy.wast:1336
assert_return(() => call($16, "check_t0", [2]), 3);

// table_copy.wast:1337
assert_return(() => call($16, "check_t0", [3]), 1);

// table_copy.wast:1338
assert_return(() => call($16, "check_t0", [4]), 4);

// table_copy.wast:1339
assert_return(() => call($16, "check_t0", [5]), 1);

// table_copy.wast:1340
assert_trap(() => call($16, "check_t0", [6]));

// table_copy.wast:1341
assert_trap(() => call($16, "check_t0", [7]));

// table_copy.wast:1342
assert_trap(() => call($16, "check_t0", [8]));

// table_copy.wast:1343
assert_trap(() => call($16, "check_t0", [9]));

// table_copy.wast:1344
assert_trap(() => call($16, "check_t0", [10]));

// table_copy.wast:1345
assert_trap(() => call($16, "check_t0", [11]));

// table_copy.wast:1346
assert_return(() => call($16, "check_t0", [12]), 7);

// table_copy.wast:1347
assert_return(() => call($16, "check_t0", [13]), 5);

// table_copy.wast:1348
assert_return(() => call($16, "check_t0", [14]), 2);

// table_copy.wast:1349
assert_return(() => call($16, "check_t0", [15]), 3);

// table_copy.wast:1350
assert_return(() => call($16, "check_t0", [16]), 6);

// table_copy.wast:1351
assert_trap(() => call($16, "check_t0", [17]));

// table_copy.wast:1352
assert_trap(() => call($16, "check_t0", [18]));

// table_copy.wast:1353
assert_trap(() => call($16, "check_t0", [19]));

// table_copy.wast:1354
assert_trap(() => call($16, "check_t0", [20]));

// table_copy.wast:1355
assert_trap(() => call($16, "check_t0", [21]));

// table_copy.wast:1356
assert_trap(() => call($16, "check_t0", [22]));

// table_copy.wast:1357
assert_trap(() => call($16, "check_t0", [23]));

// table_copy.wast:1358
assert_trap(() => call($16, "check_t0", [24]));

// table_copy.wast:1359
assert_trap(() => call($16, "check_t0", [25]));

// table_copy.wast:1360
assert_return(() => call($16, "check_t0", [26]), 3);

// table_copy.wast:1361
assert_return(() => call($16, "check_t0", [27]), 1);

// table_copy.wast:1362
assert_trap(() => call($16, "check_t0", [28]));

// table_copy.wast:1363
assert_trap(() => call($16, "check_t0", [29]));

// table_copy.wast:1364
assert_trap(() => call($16, "check_t1", [0]));

// table_copy.wast:1365
assert_trap(() => call($16, "check_t1", [1]));

// table_copy.wast:1366
assert_trap(() => call($16, "check_t1", [2]));

// table_copy.wast:1367
assert_return(() => call($16, "check_t1", [3]), 1);

// table_copy.wast:1368
assert_return(() => call($16, "check_t1", [4]), 3);

// table_copy.wast:1369
assert_return(() => call($16, "check_t1", [5]), 1);

// table_copy.wast:1370
assert_return(() => call($16, "check_t1", [6]), 4);

// table_copy.wast:1371
assert_trap(() => call($16, "check_t1", [7]));

// table_copy.wast:1372
assert_trap(() => call($16, "check_t1", [8]));

// table_copy.wast:1373
assert_trap(() => call($16, "check_t1", [9]));

// table_copy.wast:1374
assert_trap(() => call($16, "check_t1", [10]));

// table_copy.wast:1375
assert_return(() => call($16, "check_t1", [11]), 6);

// table_copy.wast:1376
assert_return(() => call($16, "check_t1", [12]), 3);

// table_copy.wast:1377
assert_return(() => call($16, "check_t1", [13]), 2);

// table_copy.wast:1378
assert_return(() => call($16, "check_t1", [14]), 5);

// table_copy.wast:1379
assert_return(() => call($16, "check_t1", [15]), 7);

// table_copy.wast:1380
assert_trap(() => call($16, "check_t1", [16]));

// table_copy.wast:1381
assert_trap(() => call($16, "check_t1", [17]));

// table_copy.wast:1382
assert_trap(() => call($16, "check_t1", [18]));

// table_copy.wast:1383
assert_trap(() => call($16, "check_t1", [19]));

// table_copy.wast:1384
assert_trap(() => call($16, "check_t1", [20]));

// table_copy.wast:1385
assert_trap(() => call($16, "check_t1", [21]));

// table_copy.wast:1386
assert_trap(() => call($16, "check_t1", [22]));

// table_copy.wast:1387
assert_trap(() => call($16, "check_t1", [23]));

// table_copy.wast:1388
assert_trap(() => call($16, "check_t1", [24]));

// table_copy.wast:1389
assert_trap(() => call($16, "check_t1", [25]));

// table_copy.wast:1390
assert_trap(() => call($16, "check_t1", [26]));

// table_copy.wast:1391
assert_trap(() => call($16, "check_t1", [27]));

// table_copy.wast:1392
assert_trap(() => call($16, "check_t1", [28]));

// table_copy.wast:1393
assert_trap(() => call($16, "check_t1", [29]));

// table_copy.wast:1395
let $17 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x0c\x41\x07\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1425
run(() => call($17, "test", []));

// table_copy.wast:1426
assert_trap(() => call($17, "check_t0", [0]));

// table_copy.wast:1427
assert_trap(() => call($17, "check_t0", [1]));

// table_copy.wast:1428
assert_return(() => call($17, "check_t0", [2]), 3);

// table_copy.wast:1429
assert_return(() => call($17, "check_t0", [3]), 1);

// table_copy.wast:1430
assert_return(() => call($17, "check_t0", [4]), 4);

// table_copy.wast:1431
assert_return(() => call($17, "check_t0", [5]), 1);

// table_copy.wast:1432
assert_trap(() => call($17, "check_t0", [6]));

// table_copy.wast:1433
assert_trap(() => call($17, "check_t0", [7]));

// table_copy.wast:1434
assert_trap(() => call($17, "check_t0", [8]));

// table_copy.wast:1435
assert_trap(() => call($17, "check_t0", [9]));

// table_copy.wast:1436
assert_return(() => call($17, "check_t0", [10]), 7);

// table_copy.wast:1437
assert_return(() => call($17, "check_t0", [11]), 5);

// table_copy.wast:1438
assert_return(() => call($17, "check_t0", [12]), 2);

// table_copy.wast:1439
assert_return(() => call($17, "check_t0", [13]), 3);

// table_copy.wast:1440
assert_return(() => call($17, "check_t0", [14]), 6);

// table_copy.wast:1441
assert_trap(() => call($17, "check_t0", [15]));

// table_copy.wast:1442
assert_trap(() => call($17, "check_t0", [16]));

// table_copy.wast:1443
assert_trap(() => call($17, "check_t0", [17]));

// table_copy.wast:1444
assert_trap(() => call($17, "check_t0", [18]));

// table_copy.wast:1445
assert_trap(() => call($17, "check_t0", [19]));

// table_copy.wast:1446
assert_trap(() => call($17, "check_t0", [20]));

// table_copy.wast:1447
assert_trap(() => call($17, "check_t0", [21]));

// table_copy.wast:1448
assert_trap(() => call($17, "check_t0", [22]));

// table_copy.wast:1449
assert_trap(() => call($17, "check_t0", [23]));

// table_copy.wast:1450
assert_trap(() => call($17, "check_t0", [24]));

// table_copy.wast:1451
assert_trap(() => call($17, "check_t0", [25]));

// table_copy.wast:1452
assert_trap(() => call($17, "check_t0", [26]));

// table_copy.wast:1453
assert_trap(() => call($17, "check_t0", [27]));

// table_copy.wast:1454
assert_trap(() => call($17, "check_t0", [28]));

// table_copy.wast:1455
assert_trap(() => call($17, "check_t0", [29]));

// table_copy.wast:1456
assert_trap(() => call($17, "check_t1", [0]));

// table_copy.wast:1457
assert_trap(() => call($17, "check_t1", [1]));

// table_copy.wast:1458
assert_trap(() => call($17, "check_t1", [2]));

// table_copy.wast:1459
assert_return(() => call($17, "check_t1", [3]), 1);

// table_copy.wast:1460
assert_return(() => call($17, "check_t1", [4]), 3);

// table_copy.wast:1461
assert_return(() => call($17, "check_t1", [5]), 1);

// table_copy.wast:1462
assert_return(() => call($17, "check_t1", [6]), 4);

// table_copy.wast:1463
assert_trap(() => call($17, "check_t1", [7]));

// table_copy.wast:1464
assert_trap(() => call($17, "check_t1", [8]));

// table_copy.wast:1465
assert_trap(() => call($17, "check_t1", [9]));

// table_copy.wast:1466
assert_trap(() => call($17, "check_t1", [10]));

// table_copy.wast:1467
assert_return(() => call($17, "check_t1", [11]), 6);

// table_copy.wast:1468
assert_return(() => call($17, "check_t1", [12]), 3);

// table_copy.wast:1469
assert_return(() => call($17, "check_t1", [13]), 2);

// table_copy.wast:1470
assert_return(() => call($17, "check_t1", [14]), 5);

// table_copy.wast:1471
assert_return(() => call($17, "check_t1", [15]), 7);

// table_copy.wast:1472
assert_trap(() => call($17, "check_t1", [16]));

// table_copy.wast:1473
assert_trap(() => call($17, "check_t1", [17]));

// table_copy.wast:1474
assert_trap(() => call($17, "check_t1", [18]));

// table_copy.wast:1475
assert_trap(() => call($17, "check_t1", [19]));

// table_copy.wast:1476
assert_trap(() => call($17, "check_t1", [20]));

// table_copy.wast:1477
assert_trap(() => call($17, "check_t1", [21]));

// table_copy.wast:1478
assert_trap(() => call($17, "check_t1", [22]));

// table_copy.wast:1479
assert_trap(() => call($17, "check_t1", [23]));

// table_copy.wast:1480
assert_trap(() => call($17, "check_t1", [24]));

// table_copy.wast:1481
assert_trap(() => call($17, "check_t1", [25]));

// table_copy.wast:1482
assert_trap(() => call($17, "check_t1", [26]));

// table_copy.wast:1483
assert_trap(() => call($17, "check_t1", [27]));

// table_copy.wast:1484
assert_trap(() => call($17, "check_t1", [28]));

// table_copy.wast:1485
assert_trap(() => call($17, "check_t1", [29]));

// table_copy.wast:1487
let $18 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x0a\x41\x07\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1517
run(() => call($18, "test", []));

// table_copy.wast:1518
assert_trap(() => call($18, "check_t0", [0]));

// table_copy.wast:1519
assert_trap(() => call($18, "check_t0", [1]));

// table_copy.wast:1520
assert_return(() => call($18, "check_t0", [2]), 3);

// table_copy.wast:1521
assert_return(() => call($18, "check_t0", [3]), 1);

// table_copy.wast:1522
assert_return(() => call($18, "check_t0", [4]), 4);

// table_copy.wast:1523
assert_return(() => call($18, "check_t0", [5]), 1);

// table_copy.wast:1524
assert_trap(() => call($18, "check_t0", [6]));

// table_copy.wast:1525
assert_trap(() => call($18, "check_t0", [7]));

// table_copy.wast:1526
assert_trap(() => call($18, "check_t0", [8]));

// table_copy.wast:1527
assert_trap(() => call($18, "check_t0", [9]));

// table_copy.wast:1528
assert_trap(() => call($18, "check_t0", [10]));

// table_copy.wast:1529
assert_trap(() => call($18, "check_t0", [11]));

// table_copy.wast:1530
assert_trap(() => call($18, "check_t0", [12]));

// table_copy.wast:1531
assert_trap(() => call($18, "check_t0", [13]));

// table_copy.wast:1532
assert_return(() => call($18, "check_t0", [14]), 7);

// table_copy.wast:1533
assert_return(() => call($18, "check_t0", [15]), 5);

// table_copy.wast:1534
assert_return(() => call($18, "check_t0", [16]), 2);

// table_copy.wast:1535
assert_return(() => call($18, "check_t0", [17]), 3);

// table_copy.wast:1536
assert_return(() => call($18, "check_t0", [18]), 6);

// table_copy.wast:1537
assert_trap(() => call($18, "check_t0", [19]));

// table_copy.wast:1538
assert_trap(() => call($18, "check_t0", [20]));

// table_copy.wast:1539
assert_trap(() => call($18, "check_t0", [21]));

// table_copy.wast:1540
assert_trap(() => call($18, "check_t0", [22]));

// table_copy.wast:1541
assert_trap(() => call($18, "check_t0", [23]));

// table_copy.wast:1542
assert_trap(() => call($18, "check_t0", [24]));

// table_copy.wast:1543
assert_trap(() => call($18, "check_t0", [25]));

// table_copy.wast:1544
assert_trap(() => call($18, "check_t0", [26]));

// table_copy.wast:1545
assert_trap(() => call($18, "check_t0", [27]));

// table_copy.wast:1546
assert_trap(() => call($18, "check_t0", [28]));

// table_copy.wast:1547
assert_trap(() => call($18, "check_t0", [29]));

// table_copy.wast:1548
assert_trap(() => call($18, "check_t1", [0]));

// table_copy.wast:1549
assert_trap(() => call($18, "check_t1", [1]));

// table_copy.wast:1550
assert_trap(() => call($18, "check_t1", [2]));

// table_copy.wast:1551
assert_return(() => call($18, "check_t1", [3]), 1);

// table_copy.wast:1552
assert_return(() => call($18, "check_t1", [4]), 3);

// table_copy.wast:1553
assert_return(() => call($18, "check_t1", [5]), 1);

// table_copy.wast:1554
assert_return(() => call($18, "check_t1", [6]), 4);

// table_copy.wast:1555
assert_trap(() => call($18, "check_t1", [7]));

// table_copy.wast:1556
assert_trap(() => call($18, "check_t1", [8]));

// table_copy.wast:1557
assert_trap(() => call($18, "check_t1", [9]));

// table_copy.wast:1558
assert_trap(() => call($18, "check_t1", [10]));

// table_copy.wast:1559
assert_return(() => call($18, "check_t1", [11]), 6);

// table_copy.wast:1560
assert_return(() => call($18, "check_t1", [12]), 3);

// table_copy.wast:1561
assert_return(() => call($18, "check_t1", [13]), 2);

// table_copy.wast:1562
assert_return(() => call($18, "check_t1", [14]), 5);

// table_copy.wast:1563
assert_return(() => call($18, "check_t1", [15]), 7);

// table_copy.wast:1564
assert_trap(() => call($18, "check_t1", [16]));

// table_copy.wast:1565
assert_trap(() => call($18, "check_t1", [17]));

// table_copy.wast:1566
assert_trap(() => call($18, "check_t1", [18]));

// table_copy.wast:1567
assert_trap(() => call($18, "check_t1", [19]));

// table_copy.wast:1568
assert_trap(() => call($18, "check_t1", [20]));

// table_copy.wast:1569
assert_trap(() => call($18, "check_t1", [21]));

// table_copy.wast:1570
assert_trap(() => call($18, "check_t1", [22]));

// table_copy.wast:1571
assert_trap(() => call($18, "check_t1", [23]));

// table_copy.wast:1572
assert_trap(() => call($18, "check_t1", [24]));

// table_copy.wast:1573
assert_trap(() => call($18, "check_t1", [25]));

// table_copy.wast:1574
assert_trap(() => call($18, "check_t1", [26]));

// table_copy.wast:1575
assert_trap(() => call($18, "check_t1", [27]));

// table_copy.wast:1576
assert_trap(() => call($18, "check_t1", [28]));

// table_copy.wast:1577
assert_trap(() => call($18, "check_t1", [29]));

// table_copy.wast:1579
let $19 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x89\x80\x80\x80\x00\x08\x00\x00\x00\x00\x00\x01\x02\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x9e\x80\x80\x80\x00\x03\x04\x74\x65\x73\x74\x00\x0a\x08\x63\x68\x65\x63\x6b\x5f\x74\x30\x00\x0b\x08\x63\x68\x65\x63\x6b\x5f\x74\x31\x00\x0c\x09\xba\x80\x80\x80\x00\x06\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x00\x41\x03\x0b\x04\x01\x03\x01\x04\x00\x41\x0b\x0b\x05\x06\x03\x02\x05\x07\x0a\xd7\x80\x80\x80\x00\x08\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0a\x41\x00\x41\x14\xfc\x0e\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_copy.wast:1609
run(() => call($19, "test", []));

// table_copy.wast:1610
assert_trap(() => call($19, "check_t0", [0]));

// table_copy.wast:1611
assert_trap(() => call($19, "check_t0", [1]));

// table_copy.wast:1612
assert_return(() => call($19, "check_t0", [2]), 3);

// table_copy.wast:1613
assert_return(() => call($19, "check_t0", [3]), 1);

// table_copy.wast:1614
assert_return(() => call($19, "check_t0", [4]), 4);

// table_copy.wast:1615
assert_return(() => call($19, "check_t0", [5]), 1);

// table_copy.wast:1616
assert_trap(() => call($19, "check_t0", [6]));

// table_copy.wast:1617
assert_trap(() => call($19, "check_t0", [7]));

// table_copy.wast:1618
assert_trap(() => call($19, "check_t0", [8]));

// table_copy.wast:1619
assert_trap(() => call($19, "check_t0", [9]));

// table_copy.wast:1620
assert_trap(() => call($19, "check_t0", [10]));

// table_copy.wast:1621
assert_trap(() => call($19, "check_t0", [11]));

// table_copy.wast:1622
assert_return(() => call($19, "check_t0", [12]), 7);

// table_copy.wast:1623
assert_return(() => call($19, "check_t0", [13]), 5);

// table_copy.wast:1624
assert_return(() => call($19, "check_t0", [14]), 2);

// table_copy.wast:1625
assert_return(() => call($19, "check_t0", [15]), 3);

// table_copy.wast:1626
assert_return(() => call($19, "check_t0", [16]), 6);

// table_copy.wast:1627
assert_trap(() => call($19, "check_t0", [17]));

// table_copy.wast:1628
assert_trap(() => call($19, "check_t0", [18]));

// table_copy.wast:1629
assert_trap(() => call($19, "check_t0", [19]));

// table_copy.wast:1630
assert_trap(() => call($19, "check_t0", [20]));

// table_copy.wast:1631
assert_trap(() => call($19, "check_t0", [21]));

// table_copy.wast:1632
assert_trap(() => call($19, "check_t0", [22]));

// table_copy.wast:1633
assert_trap(() => call($19, "check_t0", [23]));

// table_copy.wast:1634
assert_trap(() => call($19, "check_t0", [24]));

// table_copy.wast:1635
assert_trap(() => call($19, "check_t0", [25]));

// table_copy.wast:1636
assert_trap(() => call($19, "check_t0", [26]));

// table_copy.wast:1637
assert_trap(() => call($19, "check_t0", [27]));

// table_copy.wast:1638
assert_trap(() => call($19, "check_t0", [28]));

// table_copy.wast:1639
assert_trap(() => call($19, "check_t0", [29]));

// table_copy.wast:1640
assert_trap(() => call($19, "check_t1", [0]));

// table_copy.wast:1641
assert_trap(() => call($19, "check_t1", [1]));

// table_copy.wast:1642
assert_trap(() => call($19, "check_t1", [2]));

// table_copy.wast:1643
assert_return(() => call($19, "check_t1", [3]), 1);

// table_copy.wast:1644
assert_return(() => call($19, "check_t1", [4]), 3);

// table_copy.wast:1645
assert_return(() => call($19, "check_t1", [5]), 1);

// table_copy.wast:1646
assert_return(() => call($19, "check_t1", [6]), 4);

// table_copy.wast:1647
assert_trap(() => call($19, "check_t1", [7]));

// table_copy.wast:1648
assert_trap(() => call($19, "check_t1", [8]));

// table_copy.wast:1649
assert_trap(() => call($19, "check_t1", [9]));

// table_copy.wast:1650
assert_trap(() => call($19, "check_t1", [10]));

// table_copy.wast:1651
assert_trap(() => call($19, "check_t1", [11]));

// table_copy.wast:1652
assert_return(() => call($19, "check_t1", [12]), 3);

// table_copy.wast:1653
assert_return(() => call($19, "check_t1", [13]), 1);

// table_copy.wast:1654
assert_return(() => call($19, "check_t1", [14]), 4);

// table_copy.wast:1655
assert_return(() => call($19, "check_t1", [15]), 1);

// table_copy.wast:1656
assert_trap(() => call($19, "check_t1", [16]));

// table_copy.wast:1657
assert_trap(() => call($19, "check_t1", [17]));

// table_copy.wast:1658
assert_trap(() => call($19, "check_t1", [18]));

// table_copy.wast:1659
assert_trap(() => call($19, "check_t1", [19]));

// table_copy.wast:1660
assert_trap(() => call($19, "check_t1", [20]));

// table_copy.wast:1661
assert_trap(() => call($19, "check_t1", [21]));

// table_copy.wast:1662
assert_return(() => call($19, "check_t1", [22]), 7);

// table_copy.wast:1663
assert_return(() => call($19, "check_t1", [23]), 5);

// table_copy.wast:1664
assert_return(() => call($19, "check_t1", [24]), 2);

// table_copy.wast:1665
assert_return(() => call($19, "check_t1", [25]), 3);

// table_copy.wast:1666
assert_return(() => call($19, "check_t1", [26]), 6);

// table_copy.wast:1667
assert_trap(() => call($19, "check_t1", [27]));

// table_copy.wast:1668
assert_trap(() => call($19, "check_t1", [28]));

// table_copy.wast:1669
assert_trap(() => call($19, "check_t1", [29]));

// table_copy.wast:1671
let $20 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x01\x41\x03\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1694
assert_trap(() => call($20, "test", []));

// table_copy.wast:1696
let $21 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x7e\x41\x01\x41\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1719
assert_trap(() => call($21, "test", []));

// table_copy.wast:1721
let $22 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x06\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1744
assert_trap(() => call($22, "test", []));

// table_copy.wast:1746
let $23 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x7e\x41\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1769
assert_trap(() => call($23, "test", []));

// table_copy.wast:1771
let $24 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1794
run(() => call($24, "test", []));

// table_copy.wast:1796
let $25 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x0f\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1819
run(() => call($25, "test", []));

// table_copy.wast:1821
let $26 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x0f\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1844
assert_trap(() => call($26, "test", []));

// table_copy.wast:1846
let $27 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1e\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1869
run(() => call($27, "test", []));

// table_copy.wast:1871
let $28 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1f\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1894
assert_trap(() => call($28, "test", []));

// table_copy.wast:1896
let $29 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x1e\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1919
run(() => call($29, "test", []));

// table_copy.wast:1921
let $30 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x1f\x41\x00\xfc\x0e\x00\x00\x0b");

// table_copy.wast:1944
assert_trap(() => call($30, "test", []));

// table_copy.wast:1946
let $31 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x01\x41\x03\xfc\x0e\x01\x00\x0b");

// table_copy.wast:1969
assert_trap(() => call($31, "test", []));

// table_copy.wast:1971
let $32 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x7e\x41\x01\x41\x02\xfc\x0e\x01\x00\x0b");

// table_copy.wast:1994
assert_trap(() => call($32, "test", []));

// table_copy.wast:1996
let $33 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x06\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2019
assert_trap(() => call($33, "test", []));

// table_copy.wast:2021
let $34 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x7e\x41\x02\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2044
assert_trap(() => call($34, "test", []));

// table_copy.wast:2046
let $35 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x19\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2069
run(() => call($35, "test", []));

// table_copy.wast:2071
let $36 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x0f\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2094
run(() => call($36, "test", []));

// table_copy.wast:2096
let $37 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x0f\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2119
assert_trap(() => call($37, "test", []));

// table_copy.wast:2121
let $38 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1e\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2144
run(() => call($38, "test", []));

// table_copy.wast:2146
let $39 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x1f\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2169
assert_trap(() => call($39, "test", []));

// table_copy.wast:2171
let $40 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x1e\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2194
run(() => call($40, "test", []));

// table_copy.wast:2196
let $41 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x1f\x41\x00\xfc\x0e\x01\x00\x0b");

// table_copy.wast:2219
assert_trap(() => call($41, "test", []));

// table_copy.wast:2221
let $42 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2247
assert_trap(() => call($42, "run", [24, 0, 16]));

// table_copy.wast:2249
assert_return(() => call($42, "test", [0]), 0);

// table_copy.wast:2250
assert_return(() => call($42, "test", [1]), 1);

// table_copy.wast:2251
assert_return(() => call($42, "test", [2]), 2);

// table_copy.wast:2252
assert_return(() => call($42, "test", [3]), 3);

// table_copy.wast:2253
assert_return(() => call($42, "test", [4]), 4);

// table_copy.wast:2254
assert_return(() => call($42, "test", [5]), 5);

// table_copy.wast:2255
assert_return(() => call($42, "test", [6]), 6);

// table_copy.wast:2256
assert_return(() => call($42, "test", [7]), 7);

// table_copy.wast:2257
assert_trap(() => call($42, "test", [8]));

// table_copy.wast:2258
assert_trap(() => call($42, "test", [9]));

// table_copy.wast:2259
assert_trap(() => call($42, "test", [10]));

// table_copy.wast:2260
assert_trap(() => call($42, "test", [11]));

// table_copy.wast:2261
assert_trap(() => call($42, "test", [12]));

// table_copy.wast:2262
assert_trap(() => call($42, "test", [13]));

// table_copy.wast:2263
assert_trap(() => call($42, "test", [14]));

// table_copy.wast:2264
assert_trap(() => call($42, "test", [15]));

// table_copy.wast:2265
assert_trap(() => call($42, "test", [16]));

// table_copy.wast:2266
assert_trap(() => call($42, "test", [17]));

// table_copy.wast:2267
assert_trap(() => call($42, "test", [18]));

// table_copy.wast:2268
assert_trap(() => call($42, "test", [19]));

// table_copy.wast:2269
assert_trap(() => call($42, "test", [20]));

// table_copy.wast:2270
assert_trap(() => call($42, "test", [21]));

// table_copy.wast:2271
assert_trap(() => call($42, "test", [22]));

// table_copy.wast:2272
assert_trap(() => call($42, "test", [23]));

// table_copy.wast:2273
assert_trap(() => call($42, "test", [24]));

// table_copy.wast:2274
assert_trap(() => call($42, "test", [25]));

// table_copy.wast:2275
assert_trap(() => call($42, "test", [26]));

// table_copy.wast:2276
assert_trap(() => call($42, "test", [27]));

// table_copy.wast:2277
assert_trap(() => call($42, "test", [28]));

// table_copy.wast:2278
assert_trap(() => call($42, "test", [29]));

// table_copy.wast:2279
assert_trap(() => call($42, "test", [30]));

// table_copy.wast:2280
assert_trap(() => call($42, "test", [31]));

// table_copy.wast:2282
let $43 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8f\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x09\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2308
assert_trap(() => call($43, "run", [23, 0, 15]));

// table_copy.wast:2310
assert_return(() => call($43, "test", [0]), 0);

// table_copy.wast:2311
assert_return(() => call($43, "test", [1]), 1);

// table_copy.wast:2312
assert_return(() => call($43, "test", [2]), 2);

// table_copy.wast:2313
assert_return(() => call($43, "test", [3]), 3);

// table_copy.wast:2314
assert_return(() => call($43, "test", [4]), 4);

// table_copy.wast:2315
assert_return(() => call($43, "test", [5]), 5);

// table_copy.wast:2316
assert_return(() => call($43, "test", [6]), 6);

// table_copy.wast:2317
assert_return(() => call($43, "test", [7]), 7);

// table_copy.wast:2318
assert_return(() => call($43, "test", [8]), 8);

// table_copy.wast:2319
assert_trap(() => call($43, "test", [9]));

// table_copy.wast:2320
assert_trap(() => call($43, "test", [10]));

// table_copy.wast:2321
assert_trap(() => call($43, "test", [11]));

// table_copy.wast:2322
assert_trap(() => call($43, "test", [12]));

// table_copy.wast:2323
assert_trap(() => call($43, "test", [13]));

// table_copy.wast:2324
assert_trap(() => call($43, "test", [14]));

// table_copy.wast:2325
assert_trap(() => call($43, "test", [15]));

// table_copy.wast:2326
assert_trap(() => call($43, "test", [16]));

// table_copy.wast:2327
assert_trap(() => call($43, "test", [17]));

// table_copy.wast:2328
assert_trap(() => call($43, "test", [18]));

// table_copy.wast:2329
assert_trap(() => call($43, "test", [19]));

// table_copy.wast:2330
assert_trap(() => call($43, "test", [20]));

// table_copy.wast:2331
assert_trap(() => call($43, "test", [21]));

// table_copy.wast:2332
assert_trap(() => call($43, "test", [22]));

// table_copy.wast:2333
assert_trap(() => call($43, "test", [23]));

// table_copy.wast:2334
assert_trap(() => call($43, "test", [24]));

// table_copy.wast:2335
assert_trap(() => call($43, "test", [25]));

// table_copy.wast:2336
assert_trap(() => call($43, "test", [26]));

// table_copy.wast:2337
assert_trap(() => call($43, "test", [27]));

// table_copy.wast:2338
assert_trap(() => call($43, "test", [28]));

// table_copy.wast:2339
assert_trap(() => call($43, "test", [29]));

// table_copy.wast:2340
assert_trap(() => call($43, "test", [30]));

// table_copy.wast:2341
assert_trap(() => call($43, "test", [31]));

// table_copy.wast:2343
let $44 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2369
assert_trap(() => call($44, "run", [0, 24, 16]));

// table_copy.wast:2371
assert_trap(() => call($44, "test", [0]));

// table_copy.wast:2372
assert_trap(() => call($44, "test", [1]));

// table_copy.wast:2373
assert_trap(() => call($44, "test", [2]));

// table_copy.wast:2374
assert_trap(() => call($44, "test", [3]));

// table_copy.wast:2375
assert_trap(() => call($44, "test", [4]));

// table_copy.wast:2376
assert_trap(() => call($44, "test", [5]));

// table_copy.wast:2377
assert_trap(() => call($44, "test", [6]));

// table_copy.wast:2378
assert_trap(() => call($44, "test", [7]));

// table_copy.wast:2379
assert_trap(() => call($44, "test", [8]));

// table_copy.wast:2380
assert_trap(() => call($44, "test", [9]));

// table_copy.wast:2381
assert_trap(() => call($44, "test", [10]));

// table_copy.wast:2382
assert_trap(() => call($44, "test", [11]));

// table_copy.wast:2383
assert_trap(() => call($44, "test", [12]));

// table_copy.wast:2384
assert_trap(() => call($44, "test", [13]));

// table_copy.wast:2385
assert_trap(() => call($44, "test", [14]));

// table_copy.wast:2386
assert_trap(() => call($44, "test", [15]));

// table_copy.wast:2387
assert_trap(() => call($44, "test", [16]));

// table_copy.wast:2388
assert_trap(() => call($44, "test", [17]));

// table_copy.wast:2389
assert_trap(() => call($44, "test", [18]));

// table_copy.wast:2390
assert_trap(() => call($44, "test", [19]));

// table_copy.wast:2391
assert_trap(() => call($44, "test", [20]));

// table_copy.wast:2392
assert_trap(() => call($44, "test", [21]));

// table_copy.wast:2393
assert_trap(() => call($44, "test", [22]));

// table_copy.wast:2394
assert_trap(() => call($44, "test", [23]));

// table_copy.wast:2395
assert_return(() => call($44, "test", [24]), 0);

// table_copy.wast:2396
assert_return(() => call($44, "test", [25]), 1);

// table_copy.wast:2397
assert_return(() => call($44, "test", [26]), 2);

// table_copy.wast:2398
assert_return(() => call($44, "test", [27]), 3);

// table_copy.wast:2399
assert_return(() => call($44, "test", [28]), 4);

// table_copy.wast:2400
assert_return(() => call($44, "test", [29]), 5);

// table_copy.wast:2401
assert_return(() => call($44, "test", [30]), 6);

// table_copy.wast:2402
assert_return(() => call($44, "test", [31]), 7);

// table_copy.wast:2404
let $45 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8f\x80\x80\x80\x00\x01\x00\x41\x17\x0b\x09\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2430
assert_trap(() => call($45, "run", [0, 23, 15]));

// table_copy.wast:2432
assert_trap(() => call($45, "test", [0]));

// table_copy.wast:2433
assert_trap(() => call($45, "test", [1]));

// table_copy.wast:2434
assert_trap(() => call($45, "test", [2]));

// table_copy.wast:2435
assert_trap(() => call($45, "test", [3]));

// table_copy.wast:2436
assert_trap(() => call($45, "test", [4]));

// table_copy.wast:2437
assert_trap(() => call($45, "test", [5]));

// table_copy.wast:2438
assert_trap(() => call($45, "test", [6]));

// table_copy.wast:2439
assert_trap(() => call($45, "test", [7]));

// table_copy.wast:2440
assert_trap(() => call($45, "test", [8]));

// table_copy.wast:2441
assert_trap(() => call($45, "test", [9]));

// table_copy.wast:2442
assert_trap(() => call($45, "test", [10]));

// table_copy.wast:2443
assert_trap(() => call($45, "test", [11]));

// table_copy.wast:2444
assert_trap(() => call($45, "test", [12]));

// table_copy.wast:2445
assert_trap(() => call($45, "test", [13]));

// table_copy.wast:2446
assert_trap(() => call($45, "test", [14]));

// table_copy.wast:2447
assert_trap(() => call($45, "test", [15]));

// table_copy.wast:2448
assert_trap(() => call($45, "test", [16]));

// table_copy.wast:2449
assert_trap(() => call($45, "test", [17]));

// table_copy.wast:2450
assert_trap(() => call($45, "test", [18]));

// table_copy.wast:2451
assert_trap(() => call($45, "test", [19]));

// table_copy.wast:2452
assert_trap(() => call($45, "test", [20]));

// table_copy.wast:2453
assert_trap(() => call($45, "test", [21]));

// table_copy.wast:2454
assert_trap(() => call($45, "test", [22]));

// table_copy.wast:2455
assert_return(() => call($45, "test", [23]), 0);

// table_copy.wast:2456
assert_return(() => call($45, "test", [24]), 1);

// table_copy.wast:2457
assert_return(() => call($45, "test", [25]), 2);

// table_copy.wast:2458
assert_return(() => call($45, "test", [26]), 3);

// table_copy.wast:2459
assert_return(() => call($45, "test", [27]), 4);

// table_copy.wast:2460
assert_return(() => call($45, "test", [28]), 5);

// table_copy.wast:2461
assert_return(() => call($45, "test", [29]), 6);

// table_copy.wast:2462
assert_return(() => call($45, "test", [30]), 7);

// table_copy.wast:2463
assert_return(() => call($45, "test", [31]), 8);

// table_copy.wast:2465
let $46 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x0b\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2491
assert_trap(() => call($46, "run", [24, 11, 16]));

// table_copy.wast:2493
assert_trap(() => call($46, "test", [0]));

// table_copy.wast:2494
assert_trap(() => call($46, "test", [1]));

// table_copy.wast:2495
assert_trap(() => call($46, "test", [2]));

// table_copy.wast:2496
assert_trap(() => call($46, "test", [3]));

// table_copy.wast:2497
assert_trap(() => call($46, "test", [4]));

// table_copy.wast:2498
assert_trap(() => call($46, "test", [5]));

// table_copy.wast:2499
assert_trap(() => call($46, "test", [6]));

// table_copy.wast:2500
assert_trap(() => call($46, "test", [7]));

// table_copy.wast:2501
assert_trap(() => call($46, "test", [8]));

// table_copy.wast:2502
assert_trap(() => call($46, "test", [9]));

// table_copy.wast:2503
assert_trap(() => call($46, "test", [10]));

// table_copy.wast:2504
assert_return(() => call($46, "test", [11]), 0);

// table_copy.wast:2505
assert_return(() => call($46, "test", [12]), 1);

// table_copy.wast:2506
assert_return(() => call($46, "test", [13]), 2);

// table_copy.wast:2507
assert_return(() => call($46, "test", [14]), 3);

// table_copy.wast:2508
assert_return(() => call($46, "test", [15]), 4);

// table_copy.wast:2509
assert_return(() => call($46, "test", [16]), 5);

// table_copy.wast:2510
assert_return(() => call($46, "test", [17]), 6);

// table_copy.wast:2511
assert_return(() => call($46, "test", [18]), 7);

// table_copy.wast:2512
assert_trap(() => call($46, "test", [19]));

// table_copy.wast:2513
assert_trap(() => call($46, "test", [20]));

// table_copy.wast:2514
assert_trap(() => call($46, "test", [21]));

// table_copy.wast:2515
assert_trap(() => call($46, "test", [22]));

// table_copy.wast:2516
assert_trap(() => call($46, "test", [23]));

// table_copy.wast:2517
assert_trap(() => call($46, "test", [24]));

// table_copy.wast:2518
assert_trap(() => call($46, "test", [25]));

// table_copy.wast:2519
assert_trap(() => call($46, "test", [26]));

// table_copy.wast:2520
assert_trap(() => call($46, "test", [27]));

// table_copy.wast:2521
assert_trap(() => call($46, "test", [28]));

// table_copy.wast:2522
assert_trap(() => call($46, "test", [29]));

// table_copy.wast:2523
assert_trap(() => call($46, "test", [30]));

// table_copy.wast:2524
assert_trap(() => call($46, "test", [31]));

// table_copy.wast:2526
let $47 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2552
assert_trap(() => call($47, "run", [11, 24, 16]));

// table_copy.wast:2554
assert_trap(() => call($47, "test", [0]));

// table_copy.wast:2555
assert_trap(() => call($47, "test", [1]));

// table_copy.wast:2556
assert_trap(() => call($47, "test", [2]));

// table_copy.wast:2557
assert_trap(() => call($47, "test", [3]));

// table_copy.wast:2558
assert_trap(() => call($47, "test", [4]));

// table_copy.wast:2559
assert_trap(() => call($47, "test", [5]));

// table_copy.wast:2560
assert_trap(() => call($47, "test", [6]));

// table_copy.wast:2561
assert_trap(() => call($47, "test", [7]));

// table_copy.wast:2562
assert_trap(() => call($47, "test", [8]));

// table_copy.wast:2563
assert_trap(() => call($47, "test", [9]));

// table_copy.wast:2564
assert_trap(() => call($47, "test", [10]));

// table_copy.wast:2565
assert_trap(() => call($47, "test", [11]));

// table_copy.wast:2566
assert_trap(() => call($47, "test", [12]));

// table_copy.wast:2567
assert_trap(() => call($47, "test", [13]));

// table_copy.wast:2568
assert_trap(() => call($47, "test", [14]));

// table_copy.wast:2569
assert_trap(() => call($47, "test", [15]));

// table_copy.wast:2570
assert_trap(() => call($47, "test", [16]));

// table_copy.wast:2571
assert_trap(() => call($47, "test", [17]));

// table_copy.wast:2572
assert_trap(() => call($47, "test", [18]));

// table_copy.wast:2573
assert_trap(() => call($47, "test", [19]));

// table_copy.wast:2574
assert_trap(() => call($47, "test", [20]));

// table_copy.wast:2575
assert_trap(() => call($47, "test", [21]));

// table_copy.wast:2576
assert_trap(() => call($47, "test", [22]));

// table_copy.wast:2577
assert_trap(() => call($47, "test", [23]));

// table_copy.wast:2578
assert_return(() => call($47, "test", [24]), 0);

// table_copy.wast:2579
assert_return(() => call($47, "test", [25]), 1);

// table_copy.wast:2580
assert_return(() => call($47, "test", [26]), 2);

// table_copy.wast:2581
assert_return(() => call($47, "test", [27]), 3);

// table_copy.wast:2582
assert_return(() => call($47, "test", [28]), 4);

// table_copy.wast:2583
assert_return(() => call($47, "test", [29]), 5);

// table_copy.wast:2584
assert_return(() => call($47, "test", [30]), 6);

// table_copy.wast:2585
assert_return(() => call($47, "test", [31]), 7);

// table_copy.wast:2587
let $48 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x15\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2613
assert_trap(() => call($48, "run", [24, 21, 16]));

// table_copy.wast:2615
assert_trap(() => call($48, "test", [0]));

// table_copy.wast:2616
assert_trap(() => call($48, "test", [1]));

// table_copy.wast:2617
assert_trap(() => call($48, "test", [2]));

// table_copy.wast:2618
assert_trap(() => call($48, "test", [3]));

// table_copy.wast:2619
assert_trap(() => call($48, "test", [4]));

// table_copy.wast:2620
assert_trap(() => call($48, "test", [5]));

// table_copy.wast:2621
assert_trap(() => call($48, "test", [6]));

// table_copy.wast:2622
assert_trap(() => call($48, "test", [7]));

// table_copy.wast:2623
assert_trap(() => call($48, "test", [8]));

// table_copy.wast:2624
assert_trap(() => call($48, "test", [9]));

// table_copy.wast:2625
assert_trap(() => call($48, "test", [10]));

// table_copy.wast:2626
assert_trap(() => call($48, "test", [11]));

// table_copy.wast:2627
assert_trap(() => call($48, "test", [12]));

// table_copy.wast:2628
assert_trap(() => call($48, "test", [13]));

// table_copy.wast:2629
assert_trap(() => call($48, "test", [14]));

// table_copy.wast:2630
assert_trap(() => call($48, "test", [15]));

// table_copy.wast:2631
assert_trap(() => call($48, "test", [16]));

// table_copy.wast:2632
assert_trap(() => call($48, "test", [17]));

// table_copy.wast:2633
assert_trap(() => call($48, "test", [18]));

// table_copy.wast:2634
assert_trap(() => call($48, "test", [19]));

// table_copy.wast:2635
assert_trap(() => call($48, "test", [20]));

// table_copy.wast:2636
assert_return(() => call($48, "test", [21]), 0);

// table_copy.wast:2637
assert_return(() => call($48, "test", [22]), 1);

// table_copy.wast:2638
assert_return(() => call($48, "test", [23]), 2);

// table_copy.wast:2639
assert_return(() => call($48, "test", [24]), 3);

// table_copy.wast:2640
assert_return(() => call($48, "test", [25]), 4);

// table_copy.wast:2641
assert_return(() => call($48, "test", [26]), 5);

// table_copy.wast:2642
assert_return(() => call($48, "test", [27]), 6);

// table_copy.wast:2643
assert_return(() => call($48, "test", [28]), 7);

// table_copy.wast:2644
assert_trap(() => call($48, "test", [29]));

// table_copy.wast:2645
assert_trap(() => call($48, "test", [30]));

// table_copy.wast:2646
assert_trap(() => call($48, "test", [31]));

// table_copy.wast:2648
let $49 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x8e\x80\x80\x80\x00\x01\x00\x41\x18\x0b\x08\x00\x01\x02\x03\x04\x05\x06\x07\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2674
assert_trap(() => call($49, "run", [21, 24, 16]));

// table_copy.wast:2676
assert_trap(() => call($49, "test", [0]));

// table_copy.wast:2677
assert_trap(() => call($49, "test", [1]));

// table_copy.wast:2678
assert_trap(() => call($49, "test", [2]));

// table_copy.wast:2679
assert_trap(() => call($49, "test", [3]));

// table_copy.wast:2680
assert_trap(() => call($49, "test", [4]));

// table_copy.wast:2681
assert_trap(() => call($49, "test", [5]));

// table_copy.wast:2682
assert_trap(() => call($49, "test", [6]));

// table_copy.wast:2683
assert_trap(() => call($49, "test", [7]));

// table_copy.wast:2684
assert_trap(() => call($49, "test", [8]));

// table_copy.wast:2685
assert_trap(() => call($49, "test", [9]));

// table_copy.wast:2686
assert_trap(() => call($49, "test", [10]));

// table_copy.wast:2687
assert_trap(() => call($49, "test", [11]));

// table_copy.wast:2688
assert_trap(() => call($49, "test", [12]));

// table_copy.wast:2689
assert_trap(() => call($49, "test", [13]));

// table_copy.wast:2690
assert_trap(() => call($49, "test", [14]));

// table_copy.wast:2691
assert_trap(() => call($49, "test", [15]));

// table_copy.wast:2692
assert_trap(() => call($49, "test", [16]));

// table_copy.wast:2693
assert_trap(() => call($49, "test", [17]));

// table_copy.wast:2694
assert_trap(() => call($49, "test", [18]));

// table_copy.wast:2695
assert_trap(() => call($49, "test", [19]));

// table_copy.wast:2696
assert_trap(() => call($49, "test", [20]));

// table_copy.wast:2697
assert_trap(() => call($49, "test", [21]));

// table_copy.wast:2698
assert_trap(() => call($49, "test", [22]));

// table_copy.wast:2699
assert_trap(() => call($49, "test", [23]));

// table_copy.wast:2700
assert_return(() => call($49, "test", [24]), 0);

// table_copy.wast:2701
assert_return(() => call($49, "test", [25]), 1);

// table_copy.wast:2702
assert_return(() => call($49, "test", [26]), 2);

// table_copy.wast:2703
assert_return(() => call($49, "test", [27]), 3);

// table_copy.wast:2704
assert_return(() => call($49, "test", [28]), 4);

// table_copy.wast:2705
assert_return(() => call($49, "test", [29]), 5);

// table_copy.wast:2706
assert_return(() => call($49, "test", [30]), 6);

// table_copy.wast:2707
assert_return(() => call($49, "test", [31]), 7);

// table_copy.wast:2709
let $50 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x91\x80\x80\x80\x00\x01\x00\x41\x15\x0b\x0b\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2735
assert_trap(() => call($50, "run", [21, 21, 16]));

// table_copy.wast:2737
assert_trap(() => call($50, "test", [0]));

// table_copy.wast:2738
assert_trap(() => call($50, "test", [1]));

// table_copy.wast:2739
assert_trap(() => call($50, "test", [2]));

// table_copy.wast:2740
assert_trap(() => call($50, "test", [3]));

// table_copy.wast:2741
assert_trap(() => call($50, "test", [4]));

// table_copy.wast:2742
assert_trap(() => call($50, "test", [5]));

// table_copy.wast:2743
assert_trap(() => call($50, "test", [6]));

// table_copy.wast:2744
assert_trap(() => call($50, "test", [7]));

// table_copy.wast:2745
assert_trap(() => call($50, "test", [8]));

// table_copy.wast:2746
assert_trap(() => call($50, "test", [9]));

// table_copy.wast:2747
assert_trap(() => call($50, "test", [10]));

// table_copy.wast:2748
assert_trap(() => call($50, "test", [11]));

// table_copy.wast:2749
assert_trap(() => call($50, "test", [12]));

// table_copy.wast:2750
assert_trap(() => call($50, "test", [13]));

// table_copy.wast:2751
assert_trap(() => call($50, "test", [14]));

// table_copy.wast:2752
assert_trap(() => call($50, "test", [15]));

// table_copy.wast:2753
assert_trap(() => call($50, "test", [16]));

// table_copy.wast:2754
assert_trap(() => call($50, "test", [17]));

// table_copy.wast:2755
assert_trap(() => call($50, "test", [18]));

// table_copy.wast:2756
assert_trap(() => call($50, "test", [19]));

// table_copy.wast:2757
assert_trap(() => call($50, "test", [20]));

// table_copy.wast:2758
assert_return(() => call($50, "test", [21]), 0);

// table_copy.wast:2759
assert_return(() => call($50, "test", [22]), 1);

// table_copy.wast:2760
assert_return(() => call($50, "test", [23]), 2);

// table_copy.wast:2761
assert_return(() => call($50, "test", [24]), 3);

// table_copy.wast:2762
assert_return(() => call($50, "test", [25]), 4);

// table_copy.wast:2763
assert_return(() => call($50, "test", [26]), 5);

// table_copy.wast:2764
assert_return(() => call($50, "test", [27]), 6);

// table_copy.wast:2765
assert_return(() => call($50, "test", [28]), 7);

// table_copy.wast:2766
assert_return(() => call($50, "test", [29]), 8);

// table_copy.wast:2767
assert_return(() => call($50, "test", [30]), 9);

// table_copy.wast:2768
assert_return(() => call($50, "test", [31]), 10);

// table_copy.wast:2770
let $51 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x87\x80\x80\x80\x00\x01\x70\x01\x80\x01\x80\x01\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x97\x80\x80\x80\x00\x01\x00\x41\xf0\x00\x0b\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2796
assert_trap(() => call($51, "run", [0, 112, -32]));

// table_copy.wast:2798
assert_trap(() => call($51, "test", [0]));

// table_copy.wast:2799
assert_trap(() => call($51, "test", [1]));

// table_copy.wast:2800
assert_trap(() => call($51, "test", [2]));

// table_copy.wast:2801
assert_trap(() => call($51, "test", [3]));

// table_copy.wast:2802
assert_trap(() => call($51, "test", [4]));

// table_copy.wast:2803
assert_trap(() => call($51, "test", [5]));

// table_copy.wast:2804
assert_trap(() => call($51, "test", [6]));

// table_copy.wast:2805
assert_trap(() => call($51, "test", [7]));

// table_copy.wast:2806
assert_trap(() => call($51, "test", [8]));

// table_copy.wast:2807
assert_trap(() => call($51, "test", [9]));

// table_copy.wast:2808
assert_trap(() => call($51, "test", [10]));

// table_copy.wast:2809
assert_trap(() => call($51, "test", [11]));

// table_copy.wast:2810
assert_trap(() => call($51, "test", [12]));

// table_copy.wast:2811
assert_trap(() => call($51, "test", [13]));

// table_copy.wast:2812
assert_trap(() => call($51, "test", [14]));

// table_copy.wast:2813
assert_trap(() => call($51, "test", [15]));

// table_copy.wast:2814
assert_trap(() => call($51, "test", [16]));

// table_copy.wast:2815
assert_trap(() => call($51, "test", [17]));

// table_copy.wast:2816
assert_trap(() => call($51, "test", [18]));

// table_copy.wast:2817
assert_trap(() => call($51, "test", [19]));

// table_copy.wast:2818
assert_trap(() => call($51, "test", [20]));

// table_copy.wast:2819
assert_trap(() => call($51, "test", [21]));

// table_copy.wast:2820
assert_trap(() => call($51, "test", [22]));

// table_copy.wast:2821
assert_trap(() => call($51, "test", [23]));

// table_copy.wast:2822
assert_trap(() => call($51, "test", [24]));

// table_copy.wast:2823
assert_trap(() => call($51, "test", [25]));

// table_copy.wast:2824
assert_trap(() => call($51, "test", [26]));

// table_copy.wast:2825
assert_trap(() => call($51, "test", [27]));

// table_copy.wast:2826
assert_trap(() => call($51, "test", [28]));

// table_copy.wast:2827
assert_trap(() => call($51, "test", [29]));

// table_copy.wast:2828
assert_trap(() => call($51, "test", [30]));

// table_copy.wast:2829
assert_trap(() => call($51, "test", [31]));

// table_copy.wast:2830
assert_trap(() => call($51, "test", [32]));

// table_copy.wast:2831
assert_trap(() => call($51, "test", [33]));

// table_copy.wast:2832
assert_trap(() => call($51, "test", [34]));

// table_copy.wast:2833
assert_trap(() => call($51, "test", [35]));

// table_copy.wast:2834
assert_trap(() => call($51, "test", [36]));

// table_copy.wast:2835
assert_trap(() => call($51, "test", [37]));

// table_copy.wast:2836
assert_trap(() => call($51, "test", [38]));

// table_copy.wast:2837
assert_trap(() => call($51, "test", [39]));

// table_copy.wast:2838
assert_trap(() => call($51, "test", [40]));

// table_copy.wast:2839
assert_trap(() => call($51, "test", [41]));

// table_copy.wast:2840
assert_trap(() => call($51, "test", [42]));

// table_copy.wast:2841
assert_trap(() => call($51, "test", [43]));

// table_copy.wast:2842
assert_trap(() => call($51, "test", [44]));

// table_copy.wast:2843
assert_trap(() => call($51, "test", [45]));

// table_copy.wast:2844
assert_trap(() => call($51, "test", [46]));

// table_copy.wast:2845
assert_trap(() => call($51, "test", [47]));

// table_copy.wast:2846
assert_trap(() => call($51, "test", [48]));

// table_copy.wast:2847
assert_trap(() => call($51, "test", [49]));

// table_copy.wast:2848
assert_trap(() => call($51, "test", [50]));

// table_copy.wast:2849
assert_trap(() => call($51, "test", [51]));

// table_copy.wast:2850
assert_trap(() => call($51, "test", [52]));

// table_copy.wast:2851
assert_trap(() => call($51, "test", [53]));

// table_copy.wast:2852
assert_trap(() => call($51, "test", [54]));

// table_copy.wast:2853
assert_trap(() => call($51, "test", [55]));

// table_copy.wast:2854
assert_trap(() => call($51, "test", [56]));

// table_copy.wast:2855
assert_trap(() => call($51, "test", [57]));

// table_copy.wast:2856
assert_trap(() => call($51, "test", [58]));

// table_copy.wast:2857
assert_trap(() => call($51, "test", [59]));

// table_copy.wast:2858
assert_trap(() => call($51, "test", [60]));

// table_copy.wast:2859
assert_trap(() => call($51, "test", [61]));

// table_copy.wast:2860
assert_trap(() => call($51, "test", [62]));

// table_copy.wast:2861
assert_trap(() => call($51, "test", [63]));

// table_copy.wast:2862
assert_trap(() => call($51, "test", [64]));

// table_copy.wast:2863
assert_trap(() => call($51, "test", [65]));

// table_copy.wast:2864
assert_trap(() => call($51, "test", [66]));

// table_copy.wast:2865
assert_trap(() => call($51, "test", [67]));

// table_copy.wast:2866
assert_trap(() => call($51, "test", [68]));

// table_copy.wast:2867
assert_trap(() => call($51, "test", [69]));

// table_copy.wast:2868
assert_trap(() => call($51, "test", [70]));

// table_copy.wast:2869
assert_trap(() => call($51, "test", [71]));

// table_copy.wast:2870
assert_trap(() => call($51, "test", [72]));

// table_copy.wast:2871
assert_trap(() => call($51, "test", [73]));

// table_copy.wast:2872
assert_trap(() => call($51, "test", [74]));

// table_copy.wast:2873
assert_trap(() => call($51, "test", [75]));

// table_copy.wast:2874
assert_trap(() => call($51, "test", [76]));

// table_copy.wast:2875
assert_trap(() => call($51, "test", [77]));

// table_copy.wast:2876
assert_trap(() => call($51, "test", [78]));

// table_copy.wast:2877
assert_trap(() => call($51, "test", [79]));

// table_copy.wast:2878
assert_trap(() => call($51, "test", [80]));

// table_copy.wast:2879
assert_trap(() => call($51, "test", [81]));

// table_copy.wast:2880
assert_trap(() => call($51, "test", [82]));

// table_copy.wast:2881
assert_trap(() => call($51, "test", [83]));

// table_copy.wast:2882
assert_trap(() => call($51, "test", [84]));

// table_copy.wast:2883
assert_trap(() => call($51, "test", [85]));

// table_copy.wast:2884
assert_trap(() => call($51, "test", [86]));

// table_copy.wast:2885
assert_trap(() => call($51, "test", [87]));

// table_copy.wast:2886
assert_trap(() => call($51, "test", [88]));

// table_copy.wast:2887
assert_trap(() => call($51, "test", [89]));

// table_copy.wast:2888
assert_trap(() => call($51, "test", [90]));

// table_copy.wast:2889
assert_trap(() => call($51, "test", [91]));

// table_copy.wast:2890
assert_trap(() => call($51, "test", [92]));

// table_copy.wast:2891
assert_trap(() => call($51, "test", [93]));

// table_copy.wast:2892
assert_trap(() => call($51, "test", [94]));

// table_copy.wast:2893
assert_trap(() => call($51, "test", [95]));

// table_copy.wast:2894
assert_trap(() => call($51, "test", [96]));

// table_copy.wast:2895
assert_trap(() => call($51, "test", [97]));

// table_copy.wast:2896
assert_trap(() => call($51, "test", [98]));

// table_copy.wast:2897
assert_trap(() => call($51, "test", [99]));

// table_copy.wast:2898
assert_trap(() => call($51, "test", [100]));

// table_copy.wast:2899
assert_trap(() => call($51, "test", [101]));

// table_copy.wast:2900
assert_trap(() => call($51, "test", [102]));

// table_copy.wast:2901
assert_trap(() => call($51, "test", [103]));

// table_copy.wast:2902
assert_trap(() => call($51, "test", [104]));

// table_copy.wast:2903
assert_trap(() => call($51, "test", [105]));

// table_copy.wast:2904
assert_trap(() => call($51, "test", [106]));

// table_copy.wast:2905
assert_trap(() => call($51, "test", [107]));

// table_copy.wast:2906
assert_trap(() => call($51, "test", [108]));

// table_copy.wast:2907
assert_trap(() => call($51, "test", [109]));

// table_copy.wast:2908
assert_trap(() => call($51, "test", [110]));

// table_copy.wast:2909
assert_trap(() => call($51, "test", [111]));

// table_copy.wast:2910
assert_return(() => call($51, "test", [112]), 0);

// table_copy.wast:2911
assert_return(() => call($51, "test", [113]), 1);

// table_copy.wast:2912
assert_return(() => call($51, "test", [114]), 2);

// table_copy.wast:2913
assert_return(() => call($51, "test", [115]), 3);

// table_copy.wast:2914
assert_return(() => call($51, "test", [116]), 4);

// table_copy.wast:2915
assert_return(() => call($51, "test", [117]), 5);

// table_copy.wast:2916
assert_return(() => call($51, "test", [118]), 6);

// table_copy.wast:2917
assert_return(() => call($51, "test", [119]), 7);

// table_copy.wast:2918
assert_return(() => call($51, "test", [120]), 8);

// table_copy.wast:2919
assert_return(() => call($51, "test", [121]), 9);

// table_copy.wast:2920
assert_return(() => call($51, "test", [122]), 10);

// table_copy.wast:2921
assert_return(() => call($51, "test", [123]), 11);

// table_copy.wast:2922
assert_return(() => call($51, "test", [124]), 12);

// table_copy.wast:2923
assert_return(() => call($51, "test", [125]), 13);

// table_copy.wast:2924
assert_return(() => call($51, "test", [126]), 14);

// table_copy.wast:2925
assert_return(() => call($51, "test", [127]), 15);

// table_copy.wast:2927
let $52 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x90\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x03\x7f\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x87\x80\x80\x80\x00\x01\x70\x01\x80\x01\x80\x01\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x96\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x20\x01\x20\x02\xfc\x0e\x00\x00\x0b");

// table_copy.wast:2953
assert_trap(() => call($52, "run", [112, 0, -32]));

// table_copy.wast:2955
assert_return(() => call($52, "test", [0]), 0);

// table_copy.wast:2956
assert_return(() => call($52, "test", [1]), 1);

// table_copy.wast:2957
assert_return(() => call($52, "test", [2]), 2);

// table_copy.wast:2958
assert_return(() => call($52, "test", [3]), 3);

// table_copy.wast:2959
assert_return(() => call($52, "test", [4]), 4);

// table_copy.wast:2960
assert_return(() => call($52, "test", [5]), 5);

// table_copy.wast:2961
assert_return(() => call($52, "test", [6]), 6);

// table_copy.wast:2962
assert_return(() => call($52, "test", [7]), 7);

// table_copy.wast:2963
assert_return(() => call($52, "test", [8]), 8);

// table_copy.wast:2964
assert_return(() => call($52, "test", [9]), 9);

// table_copy.wast:2965
assert_return(() => call($52, "test", [10]), 10);

// table_copy.wast:2966
assert_return(() => call($52, "test", [11]), 11);

// table_copy.wast:2967
assert_return(() => call($52, "test", [12]), 12);

// table_copy.wast:2968
assert_return(() => call($52, "test", [13]), 13);

// table_copy.wast:2969
assert_return(() => call($52, "test", [14]), 14);

// table_copy.wast:2970
assert_return(() => call($52, "test", [15]), 15);

// table_copy.wast:2971
assert_trap(() => call($52, "test", [16]));

// table_copy.wast:2972
assert_trap(() => call($52, "test", [17]));

// table_copy.wast:2973
assert_trap(() => call($52, "test", [18]));

// table_copy.wast:2974
assert_trap(() => call($52, "test", [19]));

// table_copy.wast:2975
assert_trap(() => call($52, "test", [20]));

// table_copy.wast:2976
assert_trap(() => call($52, "test", [21]));

// table_copy.wast:2977
assert_trap(() => call($52, "test", [22]));

// table_copy.wast:2978
assert_trap(() => call($52, "test", [23]));

// table_copy.wast:2979
assert_trap(() => call($52, "test", [24]));

// table_copy.wast:2980
assert_trap(() => call($52, "test", [25]));

// table_copy.wast:2981
assert_trap(() => call($52, "test", [26]));

// table_copy.wast:2982
assert_trap(() => call($52, "test", [27]));

// table_copy.wast:2983
assert_trap(() => call($52, "test", [28]));

// table_copy.wast:2984
assert_trap(() => call($52, "test", [29]));

// table_copy.wast:2985
assert_trap(() => call($52, "test", [30]));

// table_copy.wast:2986
assert_trap(() => call($52, "test", [31]));

// table_copy.wast:2987
assert_trap(() => call($52, "test", [32]));

// table_copy.wast:2988
assert_trap(() => call($52, "test", [33]));

// table_copy.wast:2989
assert_trap(() => call($52, "test", [34]));

// table_copy.wast:2990
assert_trap(() => call($52, "test", [35]));

// table_copy.wast:2991
assert_trap(() => call($52, "test", [36]));

// table_copy.wast:2992
assert_trap(() => call($52, "test", [37]));

// table_copy.wast:2993
assert_trap(() => call($52, "test", [38]));

// table_copy.wast:2994
assert_trap(() => call($52, "test", [39]));

// table_copy.wast:2995
assert_trap(() => call($52, "test", [40]));

// table_copy.wast:2996
assert_trap(() => call($52, "test", [41]));

// table_copy.wast:2997
assert_trap(() => call($52, "test", [42]));

// table_copy.wast:2998
assert_trap(() => call($52, "test", [43]));

// table_copy.wast:2999
assert_trap(() => call($52, "test", [44]));

// table_copy.wast:3000
assert_trap(() => call($52, "test", [45]));

// table_copy.wast:3001
assert_trap(() => call($52, "test", [46]));

// table_copy.wast:3002
assert_trap(() => call($52, "test", [47]));

// table_copy.wast:3003
assert_trap(() => call($52, "test", [48]));

// table_copy.wast:3004
assert_trap(() => call($52, "test", [49]));

// table_copy.wast:3005
assert_trap(() => call($52, "test", [50]));

// table_copy.wast:3006
assert_trap(() => call($52, "test", [51]));

// table_copy.wast:3007
assert_trap(() => call($52, "test", [52]));

// table_copy.wast:3008
assert_trap(() => call($52, "test", [53]));

// table_copy.wast:3009
assert_trap(() => call($52, "test", [54]));

// table_copy.wast:3010
assert_trap(() => call($52, "test", [55]));

// table_copy.wast:3011
assert_trap(() => call($52, "test", [56]));

// table_copy.wast:3012
assert_trap(() => call($52, "test", [57]));

// table_copy.wast:3013
assert_trap(() => call($52, "test", [58]));

// table_copy.wast:3014
assert_trap(() => call($52, "test", [59]));

// table_copy.wast:3015
assert_trap(() => call($52, "test", [60]));

// table_copy.wast:3016
assert_trap(() => call($52, "test", [61]));

// table_copy.wast:3017
assert_trap(() => call($52, "test", [62]));

// table_copy.wast:3018
assert_trap(() => call($52, "test", [63]));

// table_copy.wast:3019
assert_trap(() => call($52, "test", [64]));

// table_copy.wast:3020
assert_trap(() => call($52, "test", [65]));

// table_copy.wast:3021
assert_trap(() => call($52, "test", [66]));

// table_copy.wast:3022
assert_trap(() => call($52, "test", [67]));

// table_copy.wast:3023
assert_trap(() => call($52, "test", [68]));

// table_copy.wast:3024
assert_trap(() => call($52, "test", [69]));

// table_copy.wast:3025
assert_trap(() => call($52, "test", [70]));

// table_copy.wast:3026
assert_trap(() => call($52, "test", [71]));

// table_copy.wast:3027
assert_trap(() => call($52, "test", [72]));

// table_copy.wast:3028
assert_trap(() => call($52, "test", [73]));

// table_copy.wast:3029
assert_trap(() => call($52, "test", [74]));

// table_copy.wast:3030
assert_trap(() => call($52, "test", [75]));

// table_copy.wast:3031
assert_trap(() => call($52, "test", [76]));

// table_copy.wast:3032
assert_trap(() => call($52, "test", [77]));

// table_copy.wast:3033
assert_trap(() => call($52, "test", [78]));

// table_copy.wast:3034
assert_trap(() => call($52, "test", [79]));

// table_copy.wast:3035
assert_trap(() => call($52, "test", [80]));

// table_copy.wast:3036
assert_trap(() => call($52, "test", [81]));

// table_copy.wast:3037
assert_trap(() => call($52, "test", [82]));

// table_copy.wast:3038
assert_trap(() => call($52, "test", [83]));

// table_copy.wast:3039
assert_trap(() => call($52, "test", [84]));

// table_copy.wast:3040
assert_trap(() => call($52, "test", [85]));

// table_copy.wast:3041
assert_trap(() => call($52, "test", [86]));

// table_copy.wast:3042
assert_trap(() => call($52, "test", [87]));

// table_copy.wast:3043
assert_trap(() => call($52, "test", [88]));

// table_copy.wast:3044
assert_trap(() => call($52, "test", [89]));

// table_copy.wast:3045
assert_trap(() => call($52, "test", [90]));

// table_copy.wast:3046
assert_trap(() => call($52, "test", [91]));

// table_copy.wast:3047
assert_trap(() => call($52, "test", [92]));

// table_copy.wast:3048
assert_trap(() => call($52, "test", [93]));

// table_copy.wast:3049
assert_trap(() => call($52, "test", [94]));

// table_copy.wast:3050
assert_trap(() => call($52, "test", [95]));

// table_copy.wast:3051
assert_trap(() => call($52, "test", [96]));

// table_copy.wast:3052
assert_trap(() => call($52, "test", [97]));

// table_copy.wast:3053
assert_trap(() => call($52, "test", [98]));

// table_copy.wast:3054
assert_trap(() => call($52, "test", [99]));

// table_copy.wast:3055
assert_trap(() => call($52, "test", [100]));

// table_copy.wast:3056
assert_trap(() => call($52, "test", [101]));

// table_copy.wast:3057
assert_trap(() => call($52, "test", [102]));

// table_copy.wast:3058
assert_trap(() => call($52, "test", [103]));

// table_copy.wast:3059
assert_trap(() => call($52, "test", [104]));

// table_copy.wast:3060
assert_trap(() => call($52, "test", [105]));

// table_copy.wast:3061
assert_trap(() => call($52, "test", [106]));

// table_copy.wast:3062
assert_trap(() => call($52, "test", [107]));

// table_copy.wast:3063
assert_trap(() => call($52, "test", [108]));

// table_copy.wast:3064
assert_trap(() => call($52, "test", [109]));

// table_copy.wast:3065
assert_trap(() => call($52, "test", [110]));

// table_copy.wast:3066
assert_trap(() => call($52, "test", [111]));

// table_copy.wast:3067
assert_trap(() => call($52, "test", [112]));

// table_copy.wast:3068
assert_trap(() => call($52, "test", [113]));

// table_copy.wast:3069
assert_trap(() => call($52, "test", [114]));

// table_copy.wast:3070
assert_trap(() => call($52, "test", [115]));

// table_copy.wast:3071
assert_trap(() => call($52, "test", [116]));

// table_copy.wast:3072
assert_trap(() => call($52, "test", [117]));

// table_copy.wast:3073
assert_trap(() => call($52, "test", [118]));

// table_copy.wast:3074
assert_trap(() => call($52, "test", [119]));

// table_copy.wast:3075
assert_trap(() => call($52, "test", [120]));

// table_copy.wast:3076
assert_trap(() => call($52, "test", [121]));

// table_copy.wast:3077
assert_trap(() => call($52, "test", [122]));

// table_copy.wast:3078
assert_trap(() => call($52, "test", [123]));

// table_copy.wast:3079
assert_trap(() => call($52, "test", [124]));

// table_copy.wast:3080
assert_trap(() => call($52, "test", [125]));

// table_copy.wast:3081
assert_trap(() => call($52, "test", [126]));

// table_copy.wast:3082
assert_trap(() => call($52, "test", [127]));




// table_init.wast:6
let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x86\x80\x80\x80\x00\x05\x00\x00\x00\x00\x00\x07\x9f\x80\x80\x80\x00\x05\x03\x65\x66\x30\x00\x00\x03\x65\x66\x31\x00\x01\x03\x65\x66\x32\x00\x02\x03\x65\x66\x33\x00\x03\x03\x65\x66\x34\x00\x04\x0a\xae\x80\x80\x80\x00\x05\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b");

// table_init.wast:13
register("a", $1)

// table_init.wast:15
let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x88\x80\x80\x80\x00\x07\x00\x00\x00\x00\x00\x01\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x90\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x0a\x05\x63\x68\x65\x63\x6b\x00\x0b\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xcb\x80\x80\x80\x00\x07\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x07\x41\x00\x41\x04\xfc\x0c\x01\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_init.wast:41
run(() => call($2, "test", []));

// table_init.wast:42
assert_trap(() => call($2, "check", [0]));

// table_init.wast:43
assert_trap(() => call($2, "check", [1]));

// table_init.wast:44
assert_return(() => call($2, "check", [2]), 3);

// table_init.wast:45
assert_return(() => call($2, "check", [3]), 1);

// table_init.wast:46
assert_return(() => call($2, "check", [4]), 4);

// table_init.wast:47
assert_return(() => call($2, "check", [5]), 1);

// table_init.wast:48
assert_trap(() => call($2, "check", [6]));

// table_init.wast:49
assert_return(() => call($2, "check", [7]), 2);

// table_init.wast:50
assert_return(() => call($2, "check", [8]), 7);

// table_init.wast:51
assert_return(() => call($2, "check", [9]), 1);

// table_init.wast:52
assert_return(() => call($2, "check", [10]), 8);

// table_init.wast:53
assert_trap(() => call($2, "check", [11]));

// table_init.wast:54
assert_return(() => call($2, "check", [12]), 7);

// table_init.wast:55
assert_return(() => call($2, "check", [13]), 5);

// table_init.wast:56
assert_return(() => call($2, "check", [14]), 2);

// table_init.wast:57
assert_return(() => call($2, "check", [15]), 3);

// table_init.wast:58
assert_return(() => call($2, "check", [16]), 6);

// table_init.wast:59
assert_trap(() => call($2, "check", [17]));

// table_init.wast:60
assert_trap(() => call($2, "check", [18]));

// table_init.wast:61
assert_trap(() => call($2, "check", [19]));

// table_init.wast:62
assert_trap(() => call($2, "check", [20]));

// table_init.wast:63
assert_trap(() => call($2, "check", [21]));

// table_init.wast:64
assert_trap(() => call($2, "check", [22]));

// table_init.wast:65
assert_trap(() => call($2, "check", [23]));

// table_init.wast:66
assert_trap(() => call($2, "check", [24]));

// table_init.wast:67
assert_trap(() => call($2, "check", [25]));

// table_init.wast:68
assert_trap(() => call($2, "check", [26]));

// table_init.wast:69
assert_trap(() => call($2, "check", [27]));

// table_init.wast:70
assert_trap(() => call($2, "check", [28]));

// table_init.wast:71
assert_trap(() => call($2, "check", [29]));

// table_init.wast:73
let $3 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x88\x80\x80\x80\x00\x07\x00\x00\x00\x00\x00\x01\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x90\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x0a\x05\x63\x68\x65\x63\x6b\x00\x0b\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xcb\x80\x80\x80\x00\x07\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x01\x41\x03\xfc\x0c\x03\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_init.wast:99
run(() => call($3, "test", []));

// table_init.wast:100
assert_trap(() => call($3, "check", [0]));

// table_init.wast:101
assert_trap(() => call($3, "check", [1]));

// table_init.wast:102
assert_return(() => call($3, "check", [2]), 3);

// table_init.wast:103
assert_return(() => call($3, "check", [3]), 1);

// table_init.wast:104
assert_return(() => call($3, "check", [4]), 4);

// table_init.wast:105
assert_return(() => call($3, "check", [5]), 1);

// table_init.wast:106
assert_trap(() => call($3, "check", [6]));

// table_init.wast:107
assert_trap(() => call($3, "check", [7]));

// table_init.wast:108
assert_trap(() => call($3, "check", [8]));

// table_init.wast:109
assert_trap(() => call($3, "check", [9]));

// table_init.wast:110
assert_trap(() => call($3, "check", [10]));

// table_init.wast:111
assert_trap(() => call($3, "check", [11]));

// table_init.wast:112
assert_return(() => call($3, "check", [12]), 7);

// table_init.wast:113
assert_return(() => call($3, "check", [13]), 5);

// table_init.wast:114
assert_return(() => call($3, "check", [14]), 2);

// table_init.wast:115
assert_return(() => call($3, "check", [15]), 9);

// table_init.wast:116
assert_return(() => call($3, "check", [16]), 2);

// table_init.wast:117
assert_return(() => call($3, "check", [17]), 7);

// table_init.wast:118
assert_trap(() => call($3, "check", [18]));

// table_init.wast:119
assert_trap(() => call($3, "check", [19]));

// table_init.wast:120
assert_trap(() => call($3, "check", [20]));

// table_init.wast:121
assert_trap(() => call($3, "check", [21]));

// table_init.wast:122
assert_trap(() => call($3, "check", [22]));

// table_init.wast:123
assert_trap(() => call($3, "check", [23]));

// table_init.wast:124
assert_trap(() => call($3, "check", [24]));

// table_init.wast:125
assert_trap(() => call($3, "check", [25]));

// table_init.wast:126
assert_trap(() => call($3, "check", [26]));

// table_init.wast:127
assert_trap(() => call($3, "check", [27]));

// table_init.wast:128
assert_trap(() => call($3, "check", [28]));

// table_init.wast:129
assert_trap(() => call($3, "check", [29]));

// table_init.wast:131
let $4 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x88\x80\x80\x80\x00\x07\x00\x00\x00\x00\x00\x01\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x90\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x0a\x05\x63\x68\x65\x63\x6b\x00\x0b\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\x8d\x81\x80\x80\x00\x07\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\xce\x80\x80\x80\x00\x00\x41\x07\x41\x00\x41\x04\xfc\x0c\x01\x00\xfc\x0d\x01\x41\x0f\x41\x01\x41\x03\xfc\x0c\x03\x00\xfc\x0d\x03\x41\x14\x41\x0f\x41\x05\xfc\x0e\x00\x00\x41\x15\x41\x1d\x41\x01\xfc\x0e\x00\x00\x41\x18\x41\x0a\x41\x01\xfc\x0e\x00\x00\x41\x0d\x41\x0b\x41\x04\xfc\x0e\x00\x00\x41\x13\x41\x14\x41\x05\xfc\x0e\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b");

// table_init.wast:165
run(() => call($4, "test", []));

// table_init.wast:166
assert_trap(() => call($4, "check", [0]));

// table_init.wast:167
assert_trap(() => call($4, "check", [1]));

// table_init.wast:168
assert_return(() => call($4, "check", [2]), 3);

// table_init.wast:169
assert_return(() => call($4, "check", [3]), 1);

// table_init.wast:170
assert_return(() => call($4, "check", [4]), 4);

// table_init.wast:171
assert_return(() => call($4, "check", [5]), 1);

// table_init.wast:172
assert_trap(() => call($4, "check", [6]));

// table_init.wast:173
assert_return(() => call($4, "check", [7]), 2);

// table_init.wast:174
assert_return(() => call($4, "check", [8]), 7);

// table_init.wast:175
assert_return(() => call($4, "check", [9]), 1);

// table_init.wast:176
assert_return(() => call($4, "check", [10]), 8);

// table_init.wast:177
assert_trap(() => call($4, "check", [11]));

// table_init.wast:178
assert_return(() => call($4, "check", [12]), 7);

// table_init.wast:179
assert_trap(() => call($4, "check", [13]));

// table_init.wast:180
assert_return(() => call($4, "check", [14]), 7);

// table_init.wast:181
assert_return(() => call($4, "check", [15]), 5);

// table_init.wast:182
assert_return(() => call($4, "check", [16]), 2);

// table_init.wast:183
assert_return(() => call($4, "check", [17]), 7);

// table_init.wast:184
assert_trap(() => call($4, "check", [18]));

// table_init.wast:185
assert_return(() => call($4, "check", [19]), 9);

// table_init.wast:186
assert_trap(() => call($4, "check", [20]));

// table_init.wast:187
assert_return(() => call($4, "check", [21]), 7);

// table_init.wast:188
assert_trap(() => call($4, "check", [22]));

// table_init.wast:189
assert_return(() => call($4, "check", [23]), 8);

// table_init.wast:190
assert_return(() => call($4, "check", [24]), 8);

// table_init.wast:191
assert_trap(() => call($4, "check", [25]));

// table_init.wast:192
assert_trap(() => call($4, "check", [26]));

// table_init.wast:193
assert_trap(() => call($4, "check", [27]));

// table_init.wast:194
assert_trap(() => call($4, "check", [28]));

// table_init.wast:195
assert_trap(() => call($4, "check", [29]));

// table_init.wast:197
let $5 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x88\x80\x80\x80\x00\x07\x00\x00\x00\x00\x00\x01\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x90\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x0a\x05\x63\x68\x65\x63\x6b\x00\x0b\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xcb\x80\x80\x80\x00\x07\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x07\x41\x00\x41\x04\xfc\x0c\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_init.wast:223
run(() => call($5, "test", []));

// table_init.wast:224
assert_trap(() => call($5, "check", [0]));

// table_init.wast:225
assert_trap(() => call($5, "check", [1]));

// table_init.wast:226
assert_return(() => call($5, "check", [2]), 3);

// table_init.wast:227
assert_return(() => call($5, "check", [3]), 1);

// table_init.wast:228
assert_return(() => call($5, "check", [4]), 4);

// table_init.wast:229
assert_return(() => call($5, "check", [5]), 1);

// table_init.wast:230
assert_trap(() => call($5, "check", [6]));

// table_init.wast:231
assert_return(() => call($5, "check", [7]), 2);

// table_init.wast:232
assert_return(() => call($5, "check", [8]), 7);

// table_init.wast:233
assert_return(() => call($5, "check", [9]), 1);

// table_init.wast:234
assert_return(() => call($5, "check", [10]), 8);

// table_init.wast:235
assert_trap(() => call($5, "check", [11]));

// table_init.wast:236
assert_return(() => call($5, "check", [12]), 7);

// table_init.wast:237
assert_return(() => call($5, "check", [13]), 5);

// table_init.wast:238
assert_return(() => call($5, "check", [14]), 2);

// table_init.wast:239
assert_return(() => call($5, "check", [15]), 3);

// table_init.wast:240
assert_return(() => call($5, "check", [16]), 6);

// table_init.wast:241
assert_trap(() => call($5, "check", [17]));

// table_init.wast:242
assert_trap(() => call($5, "check", [18]));

// table_init.wast:243
assert_trap(() => call($5, "check", [19]));

// table_init.wast:244
assert_trap(() => call($5, "check", [20]));

// table_init.wast:245
assert_trap(() => call($5, "check", [21]));

// table_init.wast:246
assert_trap(() => call($5, "check", [22]));

// table_init.wast:247
assert_trap(() => call($5, "check", [23]));

// table_init.wast:248
assert_trap(() => call($5, "check", [24]));

// table_init.wast:249
assert_trap(() => call($5, "check", [25]));

// table_init.wast:250
assert_trap(() => call($5, "check", [26]));

// table_init.wast:251
assert_trap(() => call($5, "check", [27]));

// table_init.wast:252
assert_trap(() => call($5, "check", [28]));

// table_init.wast:253
assert_trap(() => call($5, "check", [29]));

// table_init.wast:255
let $6 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x88\x80\x80\x80\x00\x07\x00\x00\x00\x00\x00\x01\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x90\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x0a\x05\x63\x68\x65\x63\x6b\x00\x0b\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xcb\x80\x80\x80\x00\x07\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0f\x41\x01\x41\x03\xfc\x0c\x03\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_init.wast:281
run(() => call($6, "test", []));

// table_init.wast:282
assert_trap(() => call($6, "check", [0]));

// table_init.wast:283
assert_trap(() => call($6, "check", [1]));

// table_init.wast:284
assert_return(() => call($6, "check", [2]), 3);

// table_init.wast:285
assert_return(() => call($6, "check", [3]), 1);

// table_init.wast:286
assert_return(() => call($6, "check", [4]), 4);

// table_init.wast:287
assert_return(() => call($6, "check", [5]), 1);

// table_init.wast:288
assert_trap(() => call($6, "check", [6]));

// table_init.wast:289
assert_trap(() => call($6, "check", [7]));

// table_init.wast:290
assert_trap(() => call($6, "check", [8]));

// table_init.wast:291
assert_trap(() => call($6, "check", [9]));

// table_init.wast:292
assert_trap(() => call($6, "check", [10]));

// table_init.wast:293
assert_trap(() => call($6, "check", [11]));

// table_init.wast:294
assert_return(() => call($6, "check", [12]), 7);

// table_init.wast:295
assert_return(() => call($6, "check", [13]), 5);

// table_init.wast:296
assert_return(() => call($6, "check", [14]), 2);

// table_init.wast:297
assert_return(() => call($6, "check", [15]), 9);

// table_init.wast:298
assert_return(() => call($6, "check", [16]), 2);

// table_init.wast:299
assert_return(() => call($6, "check", [17]), 7);

// table_init.wast:300
assert_trap(() => call($6, "check", [18]));

// table_init.wast:301
assert_trap(() => call($6, "check", [19]));

// table_init.wast:302
assert_trap(() => call($6, "check", [20]));

// table_init.wast:303
assert_trap(() => call($6, "check", [21]));

// table_init.wast:304
assert_trap(() => call($6, "check", [22]));

// table_init.wast:305
assert_trap(() => call($6, "check", [23]));

// table_init.wast:306
assert_trap(() => call($6, "check", [24]));

// table_init.wast:307
assert_trap(() => call($6, "check", [25]));

// table_init.wast:308
assert_trap(() => call($6, "check", [26]));

// table_init.wast:309
assert_trap(() => call($6, "check", [27]));

// table_init.wast:310
assert_trap(() => call($6, "check", [28]));

// table_init.wast:311
assert_trap(() => call($6, "check", [29]));

// table_init.wast:313
let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8d\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x00\x00\x60\x01\x7f\x01\x7f\x02\xa9\x80\x80\x80\x00\x05\x01\x61\x03\x65\x66\x30\x00\x00\x01\x61\x03\x65\x66\x31\x00\x00\x01\x61\x03\x65\x66\x32\x00\x00\x01\x61\x03\x65\x66\x33\x00\x00\x01\x61\x03\x65\x66\x34\x00\x00\x03\x88\x80\x80\x80\x00\x07\x00\x00\x00\x00\x00\x01\x02\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1e\x1e\x07\x90\x80\x80\x80\x00\x02\x04\x74\x65\x73\x74\x00\x0a\x05\x63\x68\x65\x63\x6b\x00\x0b\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\x8d\x81\x80\x80\x00\x07\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\xce\x80\x80\x80\x00\x00\x41\x07\x41\x00\x41\x04\xfc\x0c\x01\x01\xfc\x0d\x01\x41\x0f\x41\x01\x41\x03\xfc\x0c\x03\x01\xfc\x0d\x03\x41\x14\x41\x0f\x41\x05\xfc\x0e\x01\x01\x41\x15\x41\x1d\x41\x01\xfc\x0e\x01\x01\x41\x18\x41\x0a\x41\x01\xfc\x0e\x01\x01\x41\x0d\x41\x0b\x41\x04\xfc\x0e\x01\x01\x41\x13\x41\x14\x41\x05\xfc\x0e\x01\x01\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x01\x0b");

// table_init.wast:347
run(() => call($7, "test", []));

// table_init.wast:348
assert_trap(() => call($7, "check", [0]));

// table_init.wast:349
assert_trap(() => call($7, "check", [1]));

// table_init.wast:350
assert_return(() => call($7, "check", [2]), 3);

// table_init.wast:351
assert_return(() => call($7, "check", [3]), 1);

// table_init.wast:352
assert_return(() => call($7, "check", [4]), 4);

// table_init.wast:353
assert_return(() => call($7, "check", [5]), 1);

// table_init.wast:354
assert_trap(() => call($7, "check", [6]));

// table_init.wast:355
assert_return(() => call($7, "check", [7]), 2);

// table_init.wast:356
assert_return(() => call($7, "check", [8]), 7);

// table_init.wast:357
assert_return(() => call($7, "check", [9]), 1);

// table_init.wast:358
assert_return(() => call($7, "check", [10]), 8);

// table_init.wast:359
assert_trap(() => call($7, "check", [11]));

// table_init.wast:360
assert_return(() => call($7, "check", [12]), 7);

// table_init.wast:361
assert_trap(() => call($7, "check", [13]));

// table_init.wast:362
assert_return(() => call($7, "check", [14]), 7);

// table_init.wast:363
assert_return(() => call($7, "check", [15]), 5);

// table_init.wast:364
assert_return(() => call($7, "check", [16]), 2);

// table_init.wast:365
assert_return(() => call($7, "check", [17]), 7);

// table_init.wast:366
assert_trap(() => call($7, "check", [18]));

// table_init.wast:367
assert_return(() => call($7, "check", [19]), 9);

// table_init.wast:368
assert_trap(() => call($7, "check", [20]));

// table_init.wast:369
assert_return(() => call($7, "check", [21]), 7);

// table_init.wast:370
assert_trap(() => call($7, "check", [22]));

// table_init.wast:371
assert_return(() => call($7, "check", [23]), 8);

// table_init.wast:372
assert_return(() => call($7, "check", [24]), 8);

// table_init.wast:373
assert_trap(() => call($7, "check", [25]));

// table_init.wast:374
assert_trap(() => call($7, "check", [26]));

// table_init.wast:375
assert_trap(() => call($7, "check", [27]));

// table_init.wast:376
assert_trap(() => call($7, "check", [28]));

// table_init.wast:377
assert_trap(() => call($7, "check", [29]));

// table_init.wast:378
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\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x8b\x80\x80\x80\x00\x01\x85\x80\x80\x80\x00\x00\xfc\x0d\x00\x0b");

// table_init.wast:384
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\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x01\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:390
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x85\x80\x80\x80\x00\x01\x01\x00\x01\x00\x0a\x94\x80\x80\x80\x00\x02\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x85\x80\x80\x80\x00\x00\xfc\x0d\x04\x0b");

// table_init.wast:398
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x01\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x85\x80\x80\x80\x00\x01\x01\x00\x01\x00\x0a\x9b\x80\x80\x80\x00\x02\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x01\x41\x01\xfc\x0c\x04\x00\x0b");

// table_init.wast:407
let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xe5\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x85\x80\x80\x80\x00\x00\xfc\x0d\x02\x0b");

// table_init.wast:429
run(() => call($8, "test", []));

// table_init.wast:431
let $9 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x01\x41\x01\xfc\x0c\x02\x00\x0b");

// table_init.wast:453
assert_trap(() => call($9, "test", []));

// table_init.wast:455
let $10 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xf6\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x96\x80\x80\x80\x00\x00\x41\x0c\x41\x01\x41\x01\xfc\x0c\x01\x00\x41\x15\x41\x01\x41\x01\xfc\x0c\x01\x00\x0b");

// table_init.wast:477
run(() => call($10, "test", []));

// table_init.wast:479
let $11 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xe8\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x88\x80\x80\x80\x00\x00\xfc\x0d\x01\xfc\x0d\x01\x0b");

// table_init.wast:501
run(() => call($11, "test", []));

// table_init.wast:503
let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xef\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8f\x80\x80\x80\x00\x00\xfc\x0d\x01\x41\x0c\x41\x01\x41\x01\xfc\x0c\x01\x00\x0b");

// table_init.wast:525
assert_trap(() => call($12, "test", []));

// table_init.wast:527
let $13 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x00\x41\x05\xfc\x0c\x01\x00\x0b");

// table_init.wast:549
assert_trap(() => call($13, "test", []));

// table_init.wast:551
let $14 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x02\x41\x03\xfc\x0c\x01\x00\x0b");

// table_init.wast:573
assert_trap(() => call($14, "test", []));

// table_init.wast:575
let $15 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x01\x41\x03\xfc\x0c\x01\x00\x0b");

// table_init.wast:597
assert_trap(() => call($15, "test", []));

// table_init.wast:599
let $16 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x04\x41\x00\xfc\x0c\x01\x00\x0b");

// table_init.wast:621
run(() => call($16, "test", []));

// table_init.wast:623
let $17 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x05\x41\x00\xfc\x0c\x01\x00\x0b");

// table_init.wast:645
assert_trap(() => call($17, "test", []));

// table_init.wast:647
let $18 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x02\x41\x00\xfc\x0c\x01\x00\x0b");

// table_init.wast:669
run(() => call($18, "test", []));

// table_init.wast:671
let $19 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x02\x41\x00\xfc\x0c\x01\x00\x0b");

// table_init.wast:693
assert_trap(() => call($19, "test", []));

// table_init.wast:695
let $20 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1e\x41\x04\x41\x00\xfc\x0c\x01\x00\x0b");

// table_init.wast:717
run(() => call($20, "test", []));

// table_init.wast:719
let $21 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa3\x80\x80\x80\x00\x04\x00\x41\x02\x0b\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x00\x41\x0c\x0b\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1f\x41\x05\x41\x00\xfc\x0c\x01\x00\x0b");

// table_init.wast:741
assert_trap(() => call($21, "test", []));

// table_init.wast:743
let $22 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1a\x41\x01\x41\x03\xfc\x0c\x01\x01\x0b");

// table_init.wast:765
assert_trap(() => call($22, "test", []));

// table_init.wast:767
let $23 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x04\x41\x00\xfc\x0c\x01\x01\x0b");

// table_init.wast:789
run(() => call($23, "test", []));

// table_init.wast:791
let $24 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x0c\x41\x05\x41\x00\xfc\x0c\x01\x01\x0b");

// table_init.wast:813
assert_trap(() => call($24, "test", []));

// table_init.wast:815
let $25 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x02\x41\x00\xfc\x0c\x01\x01\x0b");

// table_init.wast:837
run(() => call($25, "test", []));

// table_init.wast:839
let $26 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1d\x41\x02\x41\x00\xfc\x0c\x01\x01\x0b");

// table_init.wast:861
assert_trap(() => call($26, "test", []));

// table_init.wast:863
let $27 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1c\x41\x04\x41\x00\xfc\x0c\x01\x01\x0b");

// table_init.wast:885
run(() => call($27, "test", []));

// table_init.wast:887
let $28 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x88\x80\x80\x80\x00\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x8c\x80\x80\x80\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x04\x89\x80\x80\x80\x00\x02\x70\x01\x1e\x1e\x70\x01\x1c\x1c\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x0a\x09\xa7\x80\x80\x80\x00\x04\x02\x01\x41\x02\x0b\x00\x04\x03\x01\x04\x01\x01\x00\x04\x02\x07\x01\x08\x02\x01\x41\x0c\x0b\x00\x05\x07\x05\x02\x03\x06\x01\x00\x05\x05\x09\x02\x07\x06\x0a\xec\x80\x80\x80\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x8c\x80\x80\x80\x00\x00\x41\x1d\x41\x05\x41\x00\xfc\x0c\x01\x01\x0b");

// table_init.wast:909
assert_trap(() => call($28, "test", []));

// table_init.wast:911
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x41\x01\x41\x01\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:920
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x01\x41\x01\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:929
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x41\x01\x41\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:938
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x41\x01\x43\x00\x00\x80\x3f\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:947
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x92\x80\x80\x80\x00\x00\x41\x01\x43\x00\x00\x80\x3f\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:956
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x41\x01\x43\x00\x00\x80\x3f\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:965
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x41\x01\x43\x00\x00\x80\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:974
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x01\x42\x01\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:983
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x41\x01\x42\x01\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:992
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x01\x42\x01\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1001
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x41\x01\x42\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1010
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x41\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1019
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x41\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1028
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x41\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1037
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa7\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9a\x80\x80\x80\x00\x00\x41\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1046
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x41\x01\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1055
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x92\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x41\x01\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1064
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x41\x01\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1073
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x41\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1082
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x92\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x43\x00\x00\x80\x3f\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1091
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa2\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x95\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x43\x00\x00\x80\x3f\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1100
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x92\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x43\x00\x00\x80\x3f\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1109
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa6\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x99\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x43\x00\x00\x80\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1118
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x42\x01\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1127
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x92\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x42\x01\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1136
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x42\x01\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1145
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x42\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1154
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1163
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa6\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x99\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1172
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1181
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xaa\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9d\x80\x80\x80\x00\x00\x43\x00\x00\x80\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1190
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x42\x01\x41\x01\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1199
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x42\x01\x41\x01\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1208
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x42\x01\x41\x01\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1217
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x42\x01\x41\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1226
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x42\x01\x43\x00\x00\x80\x3f\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1235
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x92\x80\x80\x80\x00\x00\x42\x01\x43\x00\x00\x80\x3f\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1244
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x42\x01\x43\x00\x00\x80\x3f\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1253
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x42\x01\x43\x00\x00\x80\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1262
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x42\x01\x42\x01\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1271
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x9c\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8f\x80\x80\x80\x00\x00\x42\x01\x42\x01\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1280
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x42\x01\x42\x01\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1289
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x42\x01\x42\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1298
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x42\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1307
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x42\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1316
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x42\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1325
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa7\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9a\x80\x80\x80\x00\x00\x42\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1334
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x41\x01\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1343
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x41\x01\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1352
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x41\x01\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1361
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa7\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9a\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x41\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1370
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x43\x00\x00\x80\x3f\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1379
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa6\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x99\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x43\x00\x00\x80\x3f\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1388
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x43\x00\x00\x80\x3f\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1397
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xaa\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9d\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x43\x00\x00\x80\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1406
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x42\x01\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1415
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa3\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x96\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x42\x01\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1424
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa0\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x93\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x42\x01\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1433
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa7\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9a\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x42\x01\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1442
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa7\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9a\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x41\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1451
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xaa\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9d\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x43\x00\x00\x80\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1460
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xa7\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x9a\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x42\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1469
assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x74\x65\x73\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x01\x00\x03\x00\x00\x00\x0a\xae\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\xa1\x80\x80\x80\x00\x00\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\x44\x00\x00\x00\x00\x00\x00\xf0\x3f\xfc\x0c\x00\x00\x0b");

// table_init.wast:1478
let $29 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8f\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x02\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x94\x80\x80\x80\x00\x01\x01\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x41\x00\x20\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1506
assert_trap(() => call($29, "run", [24, 16]));

// table_init.wast:1507
assert_trap(() => call($29, "test", [0]));

// table_init.wast:1508
assert_trap(() => call($29, "test", [1]));

// table_init.wast:1509
assert_trap(() => call($29, "test", [2]));

// table_init.wast:1510
assert_trap(() => call($29, "test", [3]));

// table_init.wast:1511
assert_trap(() => call($29, "test", [4]));

// table_init.wast:1512
assert_trap(() => call($29, "test", [5]));

// table_init.wast:1513
assert_trap(() => call($29, "test", [6]));

// table_init.wast:1514
assert_trap(() => call($29, "test", [7]));

// table_init.wast:1515
assert_trap(() => call($29, "test", [8]));

// table_init.wast:1516
assert_trap(() => call($29, "test", [9]));

// table_init.wast:1517
assert_trap(() => call($29, "test", [10]));

// table_init.wast:1518
assert_trap(() => call($29, "test", [11]));

// table_init.wast:1519
assert_trap(() => call($29, "test", [12]));

// table_init.wast:1520
assert_trap(() => call($29, "test", [13]));

// table_init.wast:1521
assert_trap(() => call($29, "test", [14]));

// table_init.wast:1522
assert_trap(() => call($29, "test", [15]));

// table_init.wast:1523
assert_trap(() => call($29, "test", [16]));

// table_init.wast:1524
assert_trap(() => call($29, "test", [17]));

// table_init.wast:1525
assert_trap(() => call($29, "test", [18]));

// table_init.wast:1526
assert_trap(() => call($29, "test", [19]));

// table_init.wast:1527
assert_trap(() => call($29, "test", [20]));

// table_init.wast:1528
assert_trap(() => call($29, "test", [21]));

// table_init.wast:1529
assert_trap(() => call($29, "test", [22]));

// table_init.wast:1530
assert_trap(() => call($29, "test", [23]));

// table_init.wast:1531
assert_trap(() => call($29, "test", [24]));

// table_init.wast:1532
assert_trap(() => call($29, "test", [25]));

// table_init.wast:1533
assert_trap(() => call($29, "test", [26]));

// table_init.wast:1534
assert_trap(() => call($29, "test", [27]));

// table_init.wast:1535
assert_trap(() => call($29, "test", [28]));

// table_init.wast:1536
assert_trap(() => call($29, "test", [29]));

// table_init.wast:1537
assert_trap(() => call($29, "test", [30]));

// table_init.wast:1538
assert_trap(() => call($29, "test", [31]));

// table_init.wast:1540
let $30 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8f\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x02\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x20\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x94\x80\x80\x80\x00\x01\x01\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x41\x00\x20\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1568
assert_trap(() => call($30, "run", [25, 16]));

// table_init.wast:1569
assert_trap(() => call($30, "test", [0]));

// table_init.wast:1570
assert_trap(() => call($30, "test", [1]));

// table_init.wast:1571
assert_trap(() => call($30, "test", [2]));

// table_init.wast:1572
assert_trap(() => call($30, "test", [3]));

// table_init.wast:1573
assert_trap(() => call($30, "test", [4]));

// table_init.wast:1574
assert_trap(() => call($30, "test", [5]));

// table_init.wast:1575
assert_trap(() => call($30, "test", [6]));

// table_init.wast:1576
assert_trap(() => call($30, "test", [7]));

// table_init.wast:1577
assert_trap(() => call($30, "test", [8]));

// table_init.wast:1578
assert_trap(() => call($30, "test", [9]));

// table_init.wast:1579
assert_trap(() => call($30, "test", [10]));

// table_init.wast:1580
assert_trap(() => call($30, "test", [11]));

// table_init.wast:1581
assert_trap(() => call($30, "test", [12]));

// table_init.wast:1582
assert_trap(() => call($30, "test", [13]));

// table_init.wast:1583
assert_trap(() => call($30, "test", [14]));

// table_init.wast:1584
assert_trap(() => call($30, "test", [15]));

// table_init.wast:1585
assert_trap(() => call($30, "test", [16]));

// table_init.wast:1586
assert_trap(() => call($30, "test", [17]));

// table_init.wast:1587
assert_trap(() => call($30, "test", [18]));

// table_init.wast:1588
assert_trap(() => call($30, "test", [19]));

// table_init.wast:1589
assert_trap(() => call($30, "test", [20]));

// table_init.wast:1590
assert_trap(() => call($30, "test", [21]));

// table_init.wast:1591
assert_trap(() => call($30, "test", [22]));

// table_init.wast:1592
assert_trap(() => call($30, "test", [23]));

// table_init.wast:1593
assert_trap(() => call($30, "test", [24]));

// table_init.wast:1594
assert_trap(() => call($30, "test", [25]));

// table_init.wast:1595
assert_trap(() => call($30, "test", [26]));

// table_init.wast:1596
assert_trap(() => call($30, "test", [27]));

// table_init.wast:1597
assert_trap(() => call($30, "test", [28]));

// table_init.wast:1598
assert_trap(() => call($30, "test", [29]));

// table_init.wast:1599
assert_trap(() => call($30, "test", [30]));

// table_init.wast:1600
assert_trap(() => call($30, "test", [31]));

// table_init.wast:1602
let $31 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8f\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x02\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x87\x80\x80\x80\x00\x01\x70\x01\xa0\x01\xc0\x02\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x94\x80\x80\x80\x00\x01\x01\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x41\x00\x20\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1630
assert_trap(() => call($31, "run", [96, 32]));

// table_init.wast:1631
assert_trap(() => call($31, "test", [0]));

// table_init.wast:1632
assert_trap(() => call($31, "test", [1]));

// table_init.wast:1633
assert_trap(() => call($31, "test", [2]));

// table_init.wast:1634
assert_trap(() => call($31, "test", [3]));

// table_init.wast:1635
assert_trap(() => call($31, "test", [4]));

// table_init.wast:1636
assert_trap(() => call($31, "test", [5]));

// table_init.wast:1637
assert_trap(() => call($31, "test", [6]));

// table_init.wast:1638
assert_trap(() => call($31, "test", [7]));

// table_init.wast:1639
assert_trap(() => call($31, "test", [8]));

// table_init.wast:1640
assert_trap(() => call($31, "test", [9]));

// table_init.wast:1641
assert_trap(() => call($31, "test", [10]));

// table_init.wast:1642
assert_trap(() => call($31, "test", [11]));

// table_init.wast:1643
assert_trap(() => call($31, "test", [12]));

// table_init.wast:1644
assert_trap(() => call($31, "test", [13]));

// table_init.wast:1645
assert_trap(() => call($31, "test", [14]));

// table_init.wast:1646
assert_trap(() => call($31, "test", [15]));

// table_init.wast:1647
assert_trap(() => call($31, "test", [16]));

// table_init.wast:1648
assert_trap(() => call($31, "test", [17]));

// table_init.wast:1649
assert_trap(() => call($31, "test", [18]));

// table_init.wast:1650
assert_trap(() => call($31, "test", [19]));

// table_init.wast:1651
assert_trap(() => call($31, "test", [20]));

// table_init.wast:1652
assert_trap(() => call($31, "test", [21]));

// table_init.wast:1653
assert_trap(() => call($31, "test", [22]));

// table_init.wast:1654
assert_trap(() => call($31, "test", [23]));

// table_init.wast:1655
assert_trap(() => call($31, "test", [24]));

// table_init.wast:1656
assert_trap(() => call($31, "test", [25]));

// table_init.wast:1657
assert_trap(() => call($31, "test", [26]));

// table_init.wast:1658
assert_trap(() => call($31, "test", [27]));

// table_init.wast:1659
assert_trap(() => call($31, "test", [28]));

// table_init.wast:1660
assert_trap(() => call($31, "test", [29]));

// table_init.wast:1661
assert_trap(() => call($31, "test", [30]));

// table_init.wast:1662
assert_trap(() => call($31, "test", [31]));

// table_init.wast:1663
assert_trap(() => call($31, "test", [32]));

// table_init.wast:1664
assert_trap(() => call($31, "test", [33]));

// table_init.wast:1665
assert_trap(() => call($31, "test", [34]));

// table_init.wast:1666
assert_trap(() => call($31, "test", [35]));

// table_init.wast:1667
assert_trap(() => call($31, "test", [36]));

// table_init.wast:1668
assert_trap(() => call($31, "test", [37]));

// table_init.wast:1669
assert_trap(() => call($31, "test", [38]));

// table_init.wast:1670
assert_trap(() => call($31, "test", [39]));

// table_init.wast:1671
assert_trap(() => call($31, "test", [40]));

// table_init.wast:1672
assert_trap(() => call($31, "test", [41]));

// table_init.wast:1673
assert_trap(() => call($31, "test", [42]));

// table_init.wast:1674
assert_trap(() => call($31, "test", [43]));

// table_init.wast:1675
assert_trap(() => call($31, "test", [44]));

// table_init.wast:1676
assert_trap(() => call($31, "test", [45]));

// table_init.wast:1677
assert_trap(() => call($31, "test", [46]));

// table_init.wast:1678
assert_trap(() => call($31, "test", [47]));

// table_init.wast:1679
assert_trap(() => call($31, "test", [48]));

// table_init.wast:1680
assert_trap(() => call($31, "test", [49]));

// table_init.wast:1681
assert_trap(() => call($31, "test", [50]));

// table_init.wast:1682
assert_trap(() => call($31, "test", [51]));

// table_init.wast:1683
assert_trap(() => call($31, "test", [52]));

// table_init.wast:1684
assert_trap(() => call($31, "test", [53]));

// table_init.wast:1685
assert_trap(() => call($31, "test", [54]));

// table_init.wast:1686
assert_trap(() => call($31, "test", [55]));

// table_init.wast:1687
assert_trap(() => call($31, "test", [56]));

// table_init.wast:1688
assert_trap(() => call($31, "test", [57]));

// table_init.wast:1689
assert_trap(() => call($31, "test", [58]));

// table_init.wast:1690
assert_trap(() => call($31, "test", [59]));

// table_init.wast:1691
assert_trap(() => call($31, "test", [60]));

// table_init.wast:1692
assert_trap(() => call($31, "test", [61]));

// table_init.wast:1693
assert_trap(() => call($31, "test", [62]));

// table_init.wast:1694
assert_trap(() => call($31, "test", [63]));

// table_init.wast:1695
assert_trap(() => call($31, "test", [64]));

// table_init.wast:1696
assert_trap(() => call($31, "test", [65]));

// table_init.wast:1697
assert_trap(() => call($31, "test", [66]));

// table_init.wast:1698
assert_trap(() => call($31, "test", [67]));

// table_init.wast:1699
assert_trap(() => call($31, "test", [68]));

// table_init.wast:1700
assert_trap(() => call($31, "test", [69]));

// table_init.wast:1701
assert_trap(() => call($31, "test", [70]));

// table_init.wast:1702
assert_trap(() => call($31, "test", [71]));

// table_init.wast:1703
assert_trap(() => call($31, "test", [72]));

// table_init.wast:1704
assert_trap(() => call($31, "test", [73]));

// table_init.wast:1705
assert_trap(() => call($31, "test", [74]));

// table_init.wast:1706
assert_trap(() => call($31, "test", [75]));

// table_init.wast:1707
assert_trap(() => call($31, "test", [76]));

// table_init.wast:1708
assert_trap(() => call($31, "test", [77]));

// table_init.wast:1709
assert_trap(() => call($31, "test", [78]));

// table_init.wast:1710
assert_trap(() => call($31, "test", [79]));

// table_init.wast:1711
assert_trap(() => call($31, "test", [80]));

// table_init.wast:1712
assert_trap(() => call($31, "test", [81]));

// table_init.wast:1713
assert_trap(() => call($31, "test", [82]));

// table_init.wast:1714
assert_trap(() => call($31, "test", [83]));

// table_init.wast:1715
assert_trap(() => call($31, "test", [84]));

// table_init.wast:1716
assert_trap(() => call($31, "test", [85]));

// table_init.wast:1717
assert_trap(() => call($31, "test", [86]));

// table_init.wast:1718
assert_trap(() => call($31, "test", [87]));

// table_init.wast:1719
assert_trap(() => call($31, "test", [88]));

// table_init.wast:1720
assert_trap(() => call($31, "test", [89]));

// table_init.wast:1721
assert_trap(() => call($31, "test", [90]));

// table_init.wast:1722
assert_trap(() => call($31, "test", [91]));

// table_init.wast:1723
assert_trap(() => call($31, "test", [92]));

// table_init.wast:1724
assert_trap(() => call($31, "test", [93]));

// table_init.wast:1725
assert_trap(() => call($31, "test", [94]));

// table_init.wast:1726
assert_trap(() => call($31, "test", [95]));

// table_init.wast:1727
assert_trap(() => call($31, "test", [96]));

// table_init.wast:1728
assert_trap(() => call($31, "test", [97]));

// table_init.wast:1729
assert_trap(() => call($31, "test", [98]));

// table_init.wast:1730
assert_trap(() => call($31, "test", [99]));

// table_init.wast:1731
assert_trap(() => call($31, "test", [100]));

// table_init.wast:1732
assert_trap(() => call($31, "test", [101]));

// table_init.wast:1733
assert_trap(() => call($31, "test", [102]));

// table_init.wast:1734
assert_trap(() => call($31, "test", [103]));

// table_init.wast:1735
assert_trap(() => call($31, "test", [104]));

// table_init.wast:1736
assert_trap(() => call($31, "test", [105]));

// table_init.wast:1737
assert_trap(() => call($31, "test", [106]));

// table_init.wast:1738
assert_trap(() => call($31, "test", [107]));

// table_init.wast:1739
assert_trap(() => call($31, "test", [108]));

// table_init.wast:1740
assert_trap(() => call($31, "test", [109]));

// table_init.wast:1741
assert_trap(() => call($31, "test", [110]));

// table_init.wast:1742
assert_trap(() => call($31, "test", [111]));

// table_init.wast:1743
assert_trap(() => call($31, "test", [112]));

// table_init.wast:1744
assert_trap(() => call($31, "test", [113]));

// table_init.wast:1745
assert_trap(() => call($31, "test", [114]));

// table_init.wast:1746
assert_trap(() => call($31, "test", [115]));

// table_init.wast:1747
assert_trap(() => call($31, "test", [116]));

// table_init.wast:1748
assert_trap(() => call($31, "test", [117]));

// table_init.wast:1749
assert_trap(() => call($31, "test", [118]));

// table_init.wast:1750
assert_trap(() => call($31, "test", [119]));

// table_init.wast:1751
assert_trap(() => call($31, "test", [120]));

// table_init.wast:1752
assert_trap(() => call($31, "test", [121]));

// table_init.wast:1753
assert_trap(() => call($31, "test", [122]));

// table_init.wast:1754
assert_trap(() => call($31, "test", [123]));

// table_init.wast:1755
assert_trap(() => call($31, "test", [124]));

// table_init.wast:1756
assert_trap(() => call($31, "test", [125]));

// table_init.wast:1757
assert_trap(() => call($31, "test", [126]));

// table_init.wast:1758
assert_trap(() => call($31, "test", [127]));

// table_init.wast:1759
assert_trap(() => call($31, "test", [128]));

// table_init.wast:1760
assert_trap(() => call($31, "test", [129]));

// table_init.wast:1761
assert_trap(() => call($31, "test", [130]));

// table_init.wast:1762
assert_trap(() => call($31, "test", [131]));

// table_init.wast:1763
assert_trap(() => call($31, "test", [132]));

// table_init.wast:1764
assert_trap(() => call($31, "test", [133]));

// table_init.wast:1765
assert_trap(() => call($31, "test", [134]));

// table_init.wast:1766
assert_trap(() => call($31, "test", [135]));

// table_init.wast:1767
assert_trap(() => call($31, "test", [136]));

// table_init.wast:1768
assert_trap(() => call($31, "test", [137]));

// table_init.wast:1769
assert_trap(() => call($31, "test", [138]));

// table_init.wast:1770
assert_trap(() => call($31, "test", [139]));

// table_init.wast:1771
assert_trap(() => call($31, "test", [140]));

// table_init.wast:1772
assert_trap(() => call($31, "test", [141]));

// table_init.wast:1773
assert_trap(() => call($31, "test", [142]));

// table_init.wast:1774
assert_trap(() => call($31, "test", [143]));

// table_init.wast:1775
assert_trap(() => call($31, "test", [144]));

// table_init.wast:1776
assert_trap(() => call($31, "test", [145]));

// table_init.wast:1777
assert_trap(() => call($31, "test", [146]));

// table_init.wast:1778
assert_trap(() => call($31, "test", [147]));

// table_init.wast:1779
assert_trap(() => call($31, "test", [148]));

// table_init.wast:1780
assert_trap(() => call($31, "test", [149]));

// table_init.wast:1781
assert_trap(() => call($31, "test", [150]));

// table_init.wast:1782
assert_trap(() => call($31, "test", [151]));

// table_init.wast:1783
assert_trap(() => call($31, "test", [152]));

// table_init.wast:1784
assert_trap(() => call($31, "test", [153]));

// table_init.wast:1785
assert_trap(() => call($31, "test", [154]));

// table_init.wast:1786
assert_trap(() => call($31, "test", [155]));

// table_init.wast:1787
assert_trap(() => call($31, "test", [156]));

// table_init.wast:1788
assert_trap(() => call($31, "test", [157]));

// table_init.wast:1789
assert_trap(() => call($31, "test", [158]));

// table_init.wast:1790
assert_trap(() => call($31, "test", [159]));

// table_init.wast:1792
let $32 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8f\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x02\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x87\x80\x80\x80\x00\x01\x70\x01\xa0\x01\xc0\x02\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x94\x80\x80\x80\x00\x01\x01\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x41\x00\x20\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:1820
assert_trap(() => call($32, "run", [97, 31]));

// table_init.wast:1821
assert_trap(() => call($32, "test", [0]));

// table_init.wast:1822
assert_trap(() => call($32, "test", [1]));

// table_init.wast:1823
assert_trap(() => call($32, "test", [2]));

// table_init.wast:1824
assert_trap(() => call($32, "test", [3]));

// table_init.wast:1825
assert_trap(() => call($32, "test", [4]));

// table_init.wast:1826
assert_trap(() => call($32, "test", [5]));

// table_init.wast:1827
assert_trap(() => call($32, "test", [6]));

// table_init.wast:1828
assert_trap(() => call($32, "test", [7]));

// table_init.wast:1829
assert_trap(() => call($32, "test", [8]));

// table_init.wast:1830
assert_trap(() => call($32, "test", [9]));

// table_init.wast:1831
assert_trap(() => call($32, "test", [10]));

// table_init.wast:1832
assert_trap(() => call($32, "test", [11]));

// table_init.wast:1833
assert_trap(() => call($32, "test", [12]));

// table_init.wast:1834
assert_trap(() => call($32, "test", [13]));

// table_init.wast:1835
assert_trap(() => call($32, "test", [14]));

// table_init.wast:1836
assert_trap(() => call($32, "test", [15]));

// table_init.wast:1837
assert_trap(() => call($32, "test", [16]));

// table_init.wast:1838
assert_trap(() => call($32, "test", [17]));

// table_init.wast:1839
assert_trap(() => call($32, "test", [18]));

// table_init.wast:1840
assert_trap(() => call($32, "test", [19]));

// table_init.wast:1841
assert_trap(() => call($32, "test", [20]));

// table_init.wast:1842
assert_trap(() => call($32, "test", [21]));

// table_init.wast:1843
assert_trap(() => call($32, "test", [22]));

// table_init.wast:1844
assert_trap(() => call($32, "test", [23]));

// table_init.wast:1845
assert_trap(() => call($32, "test", [24]));

// table_init.wast:1846
assert_trap(() => call($32, "test", [25]));

// table_init.wast:1847
assert_trap(() => call($32, "test", [26]));

// table_init.wast:1848
assert_trap(() => call($32, "test", [27]));

// table_init.wast:1849
assert_trap(() => call($32, "test", [28]));

// table_init.wast:1850
assert_trap(() => call($32, "test", [29]));

// table_init.wast:1851
assert_trap(() => call($32, "test", [30]));

// table_init.wast:1852
assert_trap(() => call($32, "test", [31]));

// table_init.wast:1853
assert_trap(() => call($32, "test", [32]));

// table_init.wast:1854
assert_trap(() => call($32, "test", [33]));

// table_init.wast:1855
assert_trap(() => call($32, "test", [34]));

// table_init.wast:1856
assert_trap(() => call($32, "test", [35]));

// table_init.wast:1857
assert_trap(() => call($32, "test", [36]));

// table_init.wast:1858
assert_trap(() => call($32, "test", [37]));

// table_init.wast:1859
assert_trap(() => call($32, "test", [38]));

// table_init.wast:1860
assert_trap(() => call($32, "test", [39]));

// table_init.wast:1861
assert_trap(() => call($32, "test", [40]));

// table_init.wast:1862
assert_trap(() => call($32, "test", [41]));

// table_init.wast:1863
assert_trap(() => call($32, "test", [42]));

// table_init.wast:1864
assert_trap(() => call($32, "test", [43]));

// table_init.wast:1865
assert_trap(() => call($32, "test", [44]));

// table_init.wast:1866
assert_trap(() => call($32, "test", [45]));

// table_init.wast:1867
assert_trap(() => call($32, "test", [46]));

// table_init.wast:1868
assert_trap(() => call($32, "test", [47]));

// table_init.wast:1869
assert_trap(() => call($32, "test", [48]));

// table_init.wast:1870
assert_trap(() => call($32, "test", [49]));

// table_init.wast:1871
assert_trap(() => call($32, "test", [50]));

// table_init.wast:1872
assert_trap(() => call($32, "test", [51]));

// table_init.wast:1873
assert_trap(() => call($32, "test", [52]));

// table_init.wast:1874
assert_trap(() => call($32, "test", [53]));

// table_init.wast:1875
assert_trap(() => call($32, "test", [54]));

// table_init.wast:1876
assert_trap(() => call($32, "test", [55]));

// table_init.wast:1877
assert_trap(() => call($32, "test", [56]));

// table_init.wast:1878
assert_trap(() => call($32, "test", [57]));

// table_init.wast:1879
assert_trap(() => call($32, "test", [58]));

// table_init.wast:1880
assert_trap(() => call($32, "test", [59]));

// table_init.wast:1881
assert_trap(() => call($32, "test", [60]));

// table_init.wast:1882
assert_trap(() => call($32, "test", [61]));

// table_init.wast:1883
assert_trap(() => call($32, "test", [62]));

// table_init.wast:1884
assert_trap(() => call($32, "test", [63]));

// table_init.wast:1885
assert_trap(() => call($32, "test", [64]));

// table_init.wast:1886
assert_trap(() => call($32, "test", [65]));

// table_init.wast:1887
assert_trap(() => call($32, "test", [66]));

// table_init.wast:1888
assert_trap(() => call($32, "test", [67]));

// table_init.wast:1889
assert_trap(() => call($32, "test", [68]));

// table_init.wast:1890
assert_trap(() => call($32, "test", [69]));

// table_init.wast:1891
assert_trap(() => call($32, "test", [70]));

// table_init.wast:1892
assert_trap(() => call($32, "test", [71]));

// table_init.wast:1893
assert_trap(() => call($32, "test", [72]));

// table_init.wast:1894
assert_trap(() => call($32, "test", [73]));

// table_init.wast:1895
assert_trap(() => call($32, "test", [74]));

// table_init.wast:1896
assert_trap(() => call($32, "test", [75]));

// table_init.wast:1897
assert_trap(() => call($32, "test", [76]));

// table_init.wast:1898
assert_trap(() => call($32, "test", [77]));

// table_init.wast:1899
assert_trap(() => call($32, "test", [78]));

// table_init.wast:1900
assert_trap(() => call($32, "test", [79]));

// table_init.wast:1901
assert_trap(() => call($32, "test", [80]));

// table_init.wast:1902
assert_trap(() => call($32, "test", [81]));

// table_init.wast:1903
assert_trap(() => call($32, "test", [82]));

// table_init.wast:1904
assert_trap(() => call($32, "test", [83]));

// table_init.wast:1905
assert_trap(() => call($32, "test", [84]));

// table_init.wast:1906
assert_trap(() => call($32, "test", [85]));

// table_init.wast:1907
assert_trap(() => call($32, "test", [86]));

// table_init.wast:1908
assert_trap(() => call($32, "test", [87]));

// table_init.wast:1909
assert_trap(() => call($32, "test", [88]));

// table_init.wast:1910
assert_trap(() => call($32, "test", [89]));

// table_init.wast:1911
assert_trap(() => call($32, "test", [90]));

// table_init.wast:1912
assert_trap(() => call($32, "test", [91]));

// table_init.wast:1913
assert_trap(() => call($32, "test", [92]));

// table_init.wast:1914
assert_trap(() => call($32, "test", [93]));

// table_init.wast:1915
assert_trap(() => call($32, "test", [94]));

// table_init.wast:1916
assert_trap(() => call($32, "test", [95]));

// table_init.wast:1917
assert_trap(() => call($32, "test", [96]));

// table_init.wast:1918
assert_trap(() => call($32, "test", [97]));

// table_init.wast:1919
assert_trap(() => call($32, "test", [98]));

// table_init.wast:1920
assert_trap(() => call($32, "test", [99]));

// table_init.wast:1921
assert_trap(() => call($32, "test", [100]));

// table_init.wast:1922
assert_trap(() => call($32, "test", [101]));

// table_init.wast:1923
assert_trap(() => call($32, "test", [102]));

// table_init.wast:1924
assert_trap(() => call($32, "test", [103]));

// table_init.wast:1925
assert_trap(() => call($32, "test", [104]));

// table_init.wast:1926
assert_trap(() => call($32, "test", [105]));

// table_init.wast:1927
assert_trap(() => call($32, "test", [106]));

// table_init.wast:1928
assert_trap(() => call($32, "test", [107]));

// table_init.wast:1929
assert_trap(() => call($32, "test", [108]));

// table_init.wast:1930
assert_trap(() => call($32, "test", [109]));

// table_init.wast:1931
assert_trap(() => call($32, "test", [110]));

// table_init.wast:1932
assert_trap(() => call($32, "test", [111]));

// table_init.wast:1933
assert_trap(() => call($32, "test", [112]));

// table_init.wast:1934
assert_trap(() => call($32, "test", [113]));

// table_init.wast:1935
assert_trap(() => call($32, "test", [114]));

// table_init.wast:1936
assert_trap(() => call($32, "test", [115]));

// table_init.wast:1937
assert_trap(() => call($32, "test", [116]));

// table_init.wast:1938
assert_trap(() => call($32, "test", [117]));

// table_init.wast:1939
assert_trap(() => call($32, "test", [118]));

// table_init.wast:1940
assert_trap(() => call($32, "test", [119]));

// table_init.wast:1941
assert_trap(() => call($32, "test", [120]));

// table_init.wast:1942
assert_trap(() => call($32, "test", [121]));

// table_init.wast:1943
assert_trap(() => call($32, "test", [122]));

// table_init.wast:1944
assert_trap(() => call($32, "test", [123]));

// table_init.wast:1945
assert_trap(() => call($32, "test", [124]));

// table_init.wast:1946
assert_trap(() => call($32, "test", [125]));

// table_init.wast:1947
assert_trap(() => call($32, "test", [126]));

// table_init.wast:1948
assert_trap(() => call($32, "test", [127]));

// table_init.wast:1949
assert_trap(() => call($32, "test", [128]));

// table_init.wast:1950
assert_trap(() => call($32, "test", [129]));

// table_init.wast:1951
assert_trap(() => call($32, "test", [130]));

// table_init.wast:1952
assert_trap(() => call($32, "test", [131]));

// table_init.wast:1953
assert_trap(() => call($32, "test", [132]));

// table_init.wast:1954
assert_trap(() => call($32, "test", [133]));

// table_init.wast:1955
assert_trap(() => call($32, "test", [134]));

// table_init.wast:1956
assert_trap(() => call($32, "test", [135]));

// table_init.wast:1957
assert_trap(() => call($32, "test", [136]));

// table_init.wast:1958
assert_trap(() => call($32, "test", [137]));

// table_init.wast:1959
assert_trap(() => call($32, "test", [138]));

// table_init.wast:1960
assert_trap(() => call($32, "test", [139]));

// table_init.wast:1961
assert_trap(() => call($32, "test", [140]));

// table_init.wast:1962
assert_trap(() => call($32, "test", [141]));

// table_init.wast:1963
assert_trap(() => call($32, "test", [142]));

// table_init.wast:1964
assert_trap(() => call($32, "test", [143]));

// table_init.wast:1965
assert_trap(() => call($32, "test", [144]));

// table_init.wast:1966
assert_trap(() => call($32, "test", [145]));

// table_init.wast:1967
assert_trap(() => call($32, "test", [146]));

// table_init.wast:1968
assert_trap(() => call($32, "test", [147]));

// table_init.wast:1969
assert_trap(() => call($32, "test", [148]));

// table_init.wast:1970
assert_trap(() => call($32, "test", [149]));

// table_init.wast:1971
assert_trap(() => call($32, "test", [150]));

// table_init.wast:1972
assert_trap(() => call($32, "test", [151]));

// table_init.wast:1973
assert_trap(() => call($32, "test", [152]));

// table_init.wast:1974
assert_trap(() => call($32, "test", [153]));

// table_init.wast:1975
assert_trap(() => call($32, "test", [154]));

// table_init.wast:1976
assert_trap(() => call($32, "test", [155]));

// table_init.wast:1977
assert_trap(() => call($32, "test", [156]));

// table_init.wast:1978
assert_trap(() => call($32, "test", [157]));

// table_init.wast:1979
assert_trap(() => call($32, "test", [158]));

// table_init.wast:1980
assert_trap(() => call($32, "test", [159]));

// table_init.wast:1982
let $33 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8f\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x02\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x40\x40\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x94\x80\x80\x80\x00\x01\x01\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x41\x00\x20\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:2010
assert_trap(() => call($33, "run", [48, -16]));

// table_init.wast:2011
assert_trap(() => call($33, "test", [0]));

// table_init.wast:2012
assert_trap(() => call($33, "test", [1]));

// table_init.wast:2013
assert_trap(() => call($33, "test", [2]));

// table_init.wast:2014
assert_trap(() => call($33, "test", [3]));

// table_init.wast:2015
assert_trap(() => call($33, "test", [4]));

// table_init.wast:2016
assert_trap(() => call($33, "test", [5]));

// table_init.wast:2017
assert_trap(() => call($33, "test", [6]));

// table_init.wast:2018
assert_trap(() => call($33, "test", [7]));

// table_init.wast:2019
assert_trap(() => call($33, "test", [8]));

// table_init.wast:2020
assert_trap(() => call($33, "test", [9]));

// table_init.wast:2021
assert_trap(() => call($33, "test", [10]));

// table_init.wast:2022
assert_trap(() => call($33, "test", [11]));

// table_init.wast:2023
assert_trap(() => call($33, "test", [12]));

// table_init.wast:2024
assert_trap(() => call($33, "test", [13]));

// table_init.wast:2025
assert_trap(() => call($33, "test", [14]));

// table_init.wast:2026
assert_trap(() => call($33, "test", [15]));

// table_init.wast:2027
assert_trap(() => call($33, "test", [16]));

// table_init.wast:2028
assert_trap(() => call($33, "test", [17]));

// table_init.wast:2029
assert_trap(() => call($33, "test", [18]));

// table_init.wast:2030
assert_trap(() => call($33, "test", [19]));

// table_init.wast:2031
assert_trap(() => call($33, "test", [20]));

// table_init.wast:2032
assert_trap(() => call($33, "test", [21]));

// table_init.wast:2033
assert_trap(() => call($33, "test", [22]));

// table_init.wast:2034
assert_trap(() => call($33, "test", [23]));

// table_init.wast:2035
assert_trap(() => call($33, "test", [24]));

// table_init.wast:2036
assert_trap(() => call($33, "test", [25]));

// table_init.wast:2037
assert_trap(() => call($33, "test", [26]));

// table_init.wast:2038
assert_trap(() => call($33, "test", [27]));

// table_init.wast:2039
assert_trap(() => call($33, "test", [28]));

// table_init.wast:2040
assert_trap(() => call($33, "test", [29]));

// table_init.wast:2041
assert_trap(() => call($33, "test", [30]));

// table_init.wast:2042
assert_trap(() => call($33, "test", [31]));

// table_init.wast:2043
assert_trap(() => call($33, "test", [32]));

// table_init.wast:2044
assert_trap(() => call($33, "test", [33]));

// table_init.wast:2045
assert_trap(() => call($33, "test", [34]));

// table_init.wast:2046
assert_trap(() => call($33, "test", [35]));

// table_init.wast:2047
assert_trap(() => call($33, "test", [36]));

// table_init.wast:2048
assert_trap(() => call($33, "test", [37]));

// table_init.wast:2049
assert_trap(() => call($33, "test", [38]));

// table_init.wast:2050
assert_trap(() => call($33, "test", [39]));

// table_init.wast:2051
assert_trap(() => call($33, "test", [40]));

// table_init.wast:2052
assert_trap(() => call($33, "test", [41]));

// table_init.wast:2053
assert_trap(() => call($33, "test", [42]));

// table_init.wast:2054
assert_trap(() => call($33, "test", [43]));

// table_init.wast:2055
assert_trap(() => call($33, "test", [44]));

// table_init.wast:2056
assert_trap(() => call($33, "test", [45]));

// table_init.wast:2057
assert_trap(() => call($33, "test", [46]));

// table_init.wast:2058
assert_trap(() => call($33, "test", [47]));

// table_init.wast:2059
assert_trap(() => call($33, "test", [48]));

// table_init.wast:2060
assert_trap(() => call($33, "test", [49]));

// table_init.wast:2061
assert_trap(() => call($33, "test", [50]));

// table_init.wast:2062
assert_trap(() => call($33, "test", [51]));

// table_init.wast:2063
assert_trap(() => call($33, "test", [52]));

// table_init.wast:2064
assert_trap(() => call($33, "test", [53]));

// table_init.wast:2065
assert_trap(() => call($33, "test", [54]));

// table_init.wast:2066
assert_trap(() => call($33, "test", [55]));

// table_init.wast:2067
assert_trap(() => call($33, "test", [56]));

// table_init.wast:2068
assert_trap(() => call($33, "test", [57]));

// table_init.wast:2069
assert_trap(() => call($33, "test", [58]));

// table_init.wast:2070
assert_trap(() => call($33, "test", [59]));

// table_init.wast:2071
assert_trap(() => call($33, "test", [60]));

// table_init.wast:2072
assert_trap(() => call($33, "test", [61]));

// table_init.wast:2073
assert_trap(() => call($33, "test", [62]));

// table_init.wast:2074
assert_trap(() => call($33, "test", [63]));

// table_init.wast:2076
let $34 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x8f\x80\x80\x80\x00\x03\x60\x00\x01\x7f\x60\x01\x7f\x01\x7f\x60\x02\x7f\x7f\x00\x03\x93\x80\x80\x80\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x04\x85\x80\x80\x80\x00\x01\x70\x01\x10\x10\x07\xe4\x80\x80\x80\x00\x12\x02\x66\x30\x00\x00\x02\x66\x31\x00\x01\x02\x66\x32\x00\x02\x02\x66\x33\x00\x03\x02\x66\x34\x00\x04\x02\x66\x35\x00\x05\x02\x66\x36\x00\x06\x02\x66\x37\x00\x07\x02\x66\x38\x00\x08\x02\x66\x39\x00\x09\x03\x66\x31\x30\x00\x0a\x03\x66\x31\x31\x00\x0b\x03\x66\x31\x32\x00\x0c\x03\x66\x31\x33\x00\x0d\x03\x66\x31\x34\x00\x0e\x03\x66\x31\x35\x00\x0f\x04\x74\x65\x73\x74\x00\x10\x03\x72\x75\x6e\x00\x11\x09\x94\x80\x80\x80\x00\x01\x01\x00\x10\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x0a\xae\x81\x80\x80\x00\x12\x84\x80\x80\x80\x00\x00\x41\x00\x0b\x84\x80\x80\x80\x00\x00\x41\x01\x0b\x84\x80\x80\x80\x00\x00\x41\x02\x0b\x84\x80\x80\x80\x00\x00\x41\x03\x0b\x84\x80\x80\x80\x00\x00\x41\x04\x0b\x84\x80\x80\x80\x00\x00\x41\x05\x0b\x84\x80\x80\x80\x00\x00\x41\x06\x0b\x84\x80\x80\x80\x00\x00\x41\x07\x0b\x84\x80\x80\x80\x00\x00\x41\x08\x0b\x84\x80\x80\x80\x00\x00\x41\x09\x0b\x84\x80\x80\x80\x00\x00\x41\x0a\x0b\x84\x80\x80\x80\x00\x00\x41\x0b\x0b\x84\x80\x80\x80\x00\x00\x41\x0c\x0b\x84\x80\x80\x80\x00\x00\x41\x0d\x0b\x84\x80\x80\x80\x00\x00\x41\x0e\x0b\x84\x80\x80\x80\x00\x00\x41\x0f\x0b\x87\x80\x80\x80\x00\x00\x20\x00\x11\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x20\x00\x41\x08\x20\x01\xfc\x0c\x00\x00\x0b");

// table_init.wast:2104
assert_trap(() => call($34, "run", [0, -4]));

// table_init.wast:2105
assert_trap(() => call($34, "test", [0]));

// table_init.wast:2106
assert_trap(() => call($34, "test", [1]));

// table_init.wast:2107
assert_trap(() => call($34, "test", [2]));

// table_init.wast:2108
assert_trap(() => call($34, "test", [3]));

// table_init.wast:2109
assert_trap(() => call($34, "test", [4]));

// table_init.wast:2110
assert_trap(() => call($34, "test", [5]));

// table_init.wast:2111
assert_trap(() => call($34, "test", [6]));

// table_init.wast:2112
assert_trap(() => call($34, "test", [7]));

// table_init.wast:2113
assert_trap(() => call($34, "test", [8]));

// table_init.wast:2114
assert_trap(() => call($34, "test", [9]));

// table_init.wast:2115
assert_trap(() => call($34, "test", [10]));

// table_init.wast:2116
assert_trap(() => call($34, "test", [11]));

// table_init.wast:2117
assert_trap(() => call($34, "test", [12]));

// table_init.wast:2118
assert_trap(() => call($34, "test", [13]));

// table_init.wast:2119
assert_trap(() => call($34, "test", [14]));

// table_init.wast:2120
assert_trap(() => call($34, "test", [15]));

// table_init.wast:2122
let $35 = instance("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\xc4\x81\x80\x80\x00\x41\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x01\x00\x00\x0a\x92\x80\x80\x80\x00\x01\x8c\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x00\xfc\x0c\x40\x00\x0b");



//@ runWebAssemblySuite("--useWebAssemblyReferences=true")
import * as assert from '../assert.js';

function module(bytes, valid = true) {
  let buffer = new ArrayBuffer(bytes.length);
  let view = new Uint8Array(buffer);
  for (let i = 0; i < bytes.length; ++i) {
    view[i] = bytes.charCodeAt(i);
  }
  return new WebAssembly.Module(buffer);
}

async function validTableInitUnreachable() {
  /*
  (module
    (type $type1 (func (result i32)))
    (table $t 10 funcref)
    (func $f (result i32) i32.const 37)
    (elem $elem0 funcref (ref.null func) (ref.func $f) (ref.func $f))
    (func (export "run")
      (return)
      (table.init $t $elem0 (i32.const 1) (i32.const 2) (i32.const 3))
    )
  )
  */
  let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x03\x02\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x01\x09\x0d\x01\x05\x70\x03\xd0\x70\x0b\xd2\x00\x0b\xd2\x00\x0b\x0a\x14\x02\x04\x00\x41\x25\x0b\x0d\x00\x0f\x41\x01\x41\x02\x41\x03\xfc\x0c\x00\x00\x0b"));
  instance.exports.run();
}

function invalidTableInitUnreachable() {
  /*
  (module
    (type $type1 (func (result i32)))
    (table $t 10 funcref)
    (func $f (result i32) i32.const 37)
    (elem $elem0 funcref (ref.null func) (ref.func $f) (ref.func $f))
    (func (export "run")
      (return)
      (table.init $t 11 (i32.const 1) (i32.const 2) (i32.const 3))
    )
  )
  */
  assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x03\x02\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x01\x09\x0d\x01\x05\x70\x03\xd0\x70\x0b\xd2\x00\x0b\xd2\x00\x0b\x0a\x14\x02\x04\x00\x41\x25\x0b\x0d\x00\x0f\x41\x01\x41\x02\x41\x0b\xfc\x0c\x0b\x00\x0b"),
  WebAssembly.CompileError,
  "WebAssembly.Module doesn't validate: element index 11 is invalid, limit is 1, in function at index 1 (evaluating 'new WebAssembly.Module(buffer)')");

  /*
  (module
    (type $type1 (func (result i32)))
    (table $t 10 funcref)
    (func $f (result i32) i32.const 37)
    (elem $elem0 funcref (ref.null func) (ref.func $f) (ref.func $f))
    (func (export "run")
      (return)
      (table.init 11 $elem0 (i32.const 1) (i32.const 2) (i32.const 3))
    )
  )
  */
  assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x03\x02\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x01\x09\x0d\x01\x05\x70\x03\xd0\x70\x0b\xd2\x00\x0b\xd2\x00\x0b\x0a\x14\x02\x04\x00\x41\x25\x0b\x0d\x00\x0f\x41\x01\x41\x02\x41\x0b\xfc\x0c\x00\x0b\x0b"),
  WebAssembly.CompileError,
  "WebAssembly.Module doesn't validate: table index 11 is invalid, limit is 1, in function at index 1 (evaluating 'new WebAssembly.Module(buffer)')");
}

function validTableSizeUnreachable() {
  /*
  (module
    (table $t 10 funcref)
    (func (export "run")
      (return)
      (drop (table.size $t))
    )
  )
  */
  let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x09\x01\x07\x00\x0f\xfc\x10\x00\x1a\x0b"));
  instance.exports.run();
}

function invalidTableSizeUnreachable() {
  /*
  (module
    (table $t 10 funcref)
    (func (export "run")
      (return)
      (drop (table.size 10))
    )
  )
  */
  assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x09\x01\x07\x00\x0f\xfc\x10\x0a\x1a\x0b"),
  WebAssembly.CompileError,
  "WebAssembly.Module doesn't validate: table index 10 is invalid, limit is 1, in function at index 0 (evaluating 'new WebAssembly.Module(buffer)')");
}

function validElemDropUnreachable() {
  /*
  (module
    (func $f (result i32) (i32.const 37))
    (func $g (result i32) (i32.const 42))
    (table $t0 10 funcref)
    (elem $e0 func $f $f $g $g)

    (func (export "run")
      (return)
      (elem.drop $e0)
    )
  )
  */
  let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x04\x03\x00\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x02\x09\x08\x01\x01\x00\x04\x00\x00\x01\x01\x0a\x12\x03\x04\x00\x41\x25\x0b\x04\x00\x41\x2a\x0b\x06\x00\x0f\xfc\x0d\x00\x0b"));
  instance.exports.run();
}

function invalidElemDropUnreachable() {
  /*
  (module
    (func $f (result i32) (i32.const 37))
    (func $g (result i32) (i32.const 42))
    (table $t0 10 funcref)
    (elem $e0 func $f $f $g $g)

    (func (export "run")
      (return)
      (elem.drop 10)
    )
  )
  */
  assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x04\x03\x00\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x02\x09\x08\x01\x01\x00\x04\x00\x00\x01\x01\x0a\x12\x03\x04\x00\x41\x25\x0b\x04\x00\x41\x2a\x0b\x06\x00\x0f\xfc\x0d\x0a\x0b"),
  WebAssembly.CompileError,
  "WebAssembly.Module doesn't validate: element index 10 is invalid, limit is 1, in function at index 2 (evaluating 'new WebAssembly.Module(buffer)')");
}

function validTableGrowUnreachable() {
  /*
  (module
    (table $t0 10 funcref)
    (func (export "run")
      (return)
      (drop (table.grow $t0 (i32.const 37)))
    )
  )
  */
  let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x0b\x01\x09\x00\x0f\x41\x25\xfc\x0f\x00\x1a\x0b"));
  instance.exports.run();
}

function invalidTableGrowUnreachable() {
  /*
  (module
    (table $t0 10 funcref)
    (func (export "run")
      (return)
      (drop (table.grow 10 (i32.const 37)))
    )
  )
  */
  assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x0b\x01\x09\x00\x0f\x41\x25\xfc\x0f\x0a\x1a\x0b"),
  WebAssembly.CompileError,
  "WebAssembly.Module doesn't validate: table index 10 is invalid, limit is 1, in function at index 0 (evaluating 'new WebAssembly.Module(buffer)')");
}

function validTableFillUnreachable() {
  /*
  (module
    (table $t0 10 funcref)
    (func (export "run")
      (return)
      (table.fill $t0 (i32.const 0) (ref.null func) (i32.const 7))
    )
  )
  */
  let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x0e\x01\x0c\x00\x0f\x41\x00\xd0\x70\x41\x07\xfc\x11\x00\x0b"));
  instance.exports.run();
}

function invalidTableFillUnreachable() {
  /*
  (module
    (table $t0 10 funcref)
    (func (export "run")
      (return)
      (drop (table.grow 10 (i32.const 37)))
    )
  )
  */
  assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x0e\x01\x0c\x00\x0f\x41\x00\xd0\x70\x41\x07\xfc\x11\x0a\x0b"),
  WebAssembly.CompileError,
  "WebAssembly.Module doesn't validate: table index 10 is invalid, limit is 1, in function at index 0 (evaluating 'new WebAssembly.Module(buffer)')");
}

function validTableCopyUnreachable() {
  /*
  (module
    (func $f (result i32) (i32.const 37))
    (func $g (result i32) (i32.const 42))
    (table $t0 10 funcref)
    (elem (table $t0) (i32.const 0) func $f $f $g $g $f)
    (table $t1 20 funcref)
    (func (export "run")
      (return)
      (table.copy $t1 $t0 (i32.const 1) (i32.const 0) (i32.const 5))
    )
  )
  */
  let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x04\x03\x00\x00\x01\x04\x07\x02\x70\x00\x0a\x70\x00\x14\x07\x07\x01\x03\x72\x75\x6e\x00\x02\x09\x0b\x01\x00\x41\x00\x0b\x05\x00\x00\x01\x01\x00\x0a\x19\x03\x04\x00\x41\x25\x0b\x04\x00\x41\x2a\x0b\x0d\x00\x0f\x41\x01\x41\x00\x41\x05\xfc\x0e\x01\x00\x0b"));
  instance.exports.run();
}

function invalidTableCopyUnreachable() {
  /*
  (module
    (func $f (result i32) (i32.const 37))
    (func $g (result i32) (i32.const 42))
    (table $t0 10 funcref)
    (elem (table $t0) (i32.const 0) func $f $f $g $g $f)
    (table $t1 20 funcref)
    (func (export "run")
      (return)
      (table.copy 10 $t0 (i32.const 1) (i32.const 0) (i32.const 5))
    )
  )
  */
  assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x04\x03\x00\x00\x01\x04\x07\x02\x70\x00\x0a\x70\x00\x14\x07\x07\x01\x03\x72\x75\x6e\x00\x02\x09\x0b\x01\x00\x41\x00\x0b\x05\x00\x00\x01\x01\x00\x0a\x19\x03\x04\x00\x41\x25\x0b\x04\x00\x41\x2a\x0b\x0d\x00\x0f\x41\x01\x41\x00\x41\x05\xfc\x0e\x0a\x00\x0b"),
  WebAssembly.CompileError,
  "WebAssembly.Module doesn't validate: table index 10 is invalid, limit is 2, in function at index 2 (evaluating 'new WebAssembly.Module(buffer)')");
}

validTableInitUnreachable();
invalidTableInitUnreachable();

validTableSizeUnreachable();
invalidTableSizeUnreachable();

validElemDropUnreachable();
invalidElemDropUnreachable();

validTableGrowUnreachable();
invalidTableGrowUnreachable();

validTableFillUnreachable();
invalidTableFillUnreachable();

validTableCopyUnreachable();
invalidTableCopyUnreachable();

Lines 4-9 a/JSTests/wasm/spec-harness/wasm-constants.js_sec1
- a/JSTests/wasm/spec-harness/wasm-constants.js +7 lines
4		4
5	// Flags: --expose-wasm	5	// Flags: --expose-wasm
6		6
		7	let hostrefs = {};
		8	let hostsym = Symbol("hostref");
		9	function hostref(s) {
		10	if (! (s in hostrefs)) hostrefs[s] = {[hostsym]: s};
		11	return hostrefs[s];
		12	}
		13
7	function bytes() {	14	function bytes() {
8	var buffer = new ArrayBuffer(arguments.length);	15	var buffer = new ArrayBuffer(arguments.length);
9	var view = new Uint8Array(buffer);	16	var view = new Uint8Array(buffer);

Lines 69-78 a/JSTests/wasm/wasm.json_sec1
- a/JSTests/wasm/wasm.json -2 / +4 lines
69	"set_global": { "category": "special", "value": 36, "return": [], "parameter": ["any"], "immediate": [{"name": "global_index", "type": "varuint32"}], "description": "write a global variable" },	69	"set_global": { "category": "special", "value": 36, "return": [], "parameter": ["any"], "immediate": [{"name": "global_index", "type": "varuint32"}], "description": "write a global variable" },
70	"table.get": { "category": "special", "value": 37, "return": ["externref"], "parameter": ["i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "get a table value" },	70	"table.get": { "category": "special", "value": 37, "return": ["externref"], "parameter": ["i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "get a table value" },
71	"table.set": { "category": "special", "value": 38, "return": [], "parameter": ["i32", "externref"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "set a table value" },	71	"table.set": { "category": "special", "value": 38, "return": [], "parameter": ["i32", "externref"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "set a table value" },
		72	"table.init": { "category": "exttable", "value": 252, "return": [], "parameter": ["i32", "i32", "i32"], "immediate": [{"name": "element_index", "type": "varuint32"}, {"name": "table_index","type": "varuint32"}],"description": "initialize table from a given element", "extendedOp": 12 },
		73	"elem.drop": { "category": "exttable", "value": 252, "return": [], "parameter": [], "immediate": [{"name": "element_index", "type": "varuint32"}], "description": "prevents further use of a passive element segment", "extendedOp": 13 },
72	"table.grow": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": ["externref", "i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "grow a table by the given delta and return the previous size, or -1 if enough space cannot be allocated", "extendedOp": 15 },	74	"table.grow": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": ["externref", "i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "grow a table by the given delta and return the previous size, or -1 if enough space cannot be allocated", "extendedOp": 15 },
73	"table.size": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": [], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "get the size of a table", "extendedOp": 16 },	75	"table.size": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": [], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "get the size of a table", "extendedOp": 16 },
74	"table.fill": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": ["i32", "externref", "i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "fill entries [i,i+n) with the given value", "extendedOp": 17 },	76	"table.fill": { "category": "exttable", "value": 252, "return": [], "parameter": ["i32", "externref", "i32"], "immediate": [{"name": "table_index", "type": "varuint32"}], "description": "fill entries [i,i+n) with the given value", "extendedOp": 17 },
75	"table.copy": { "category": "exttable", "value": 252, "return": ["i32"], "parameter": ["i32", "i32", "i32"], "immediate": [{"name": "dst_index", "type": "varuint32"}, {"name": "src_index", "type": "varuint32"}],"description": "copy table elements from dst_table[dstOffset, dstOffset + length] to src_table[srcOffset, srcOffset + length]", "extendedOp": 14 },	77	"table.copy": { "category": "exttable", "value": 252, "return": [], "parameter": ["i32", "i32", "i32"], "immediate": [{"name": "dst_index", "type": "varuint32"}, {"name": "src_index", "type": "varuint32"}],"description": "copy table elements from dst_table[dstOffset, dstOffset + length] to src_table[srcOffset, srcOffset + length]", "extendedOp": 14 },
76	"call": { "category": "call", "value": 16, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "function_index", "type": "varuint32"}], "description": "call a function by its index" },	78	"call": { "category": "call", "value": 16, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "function_index", "type": "varuint32"}], "description": "call a function by its index" },
77	"call_indirect": { "category": "call", "value": 17, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "type_index", "type": "varuint32"}, {"name": "table_index","type": "varuint32"}],"description": "call a function indirect with an expected signature" },	79	"call_indirect": { "category": "call", "value": 17, "return": ["call"], "parameter": ["call"], "immediate": [{"name": "type_index", "type": "varuint32"}, {"name": "table_index","type": "varuint32"}],"description": "call a function indirect with an expected signature" },
78	"i32.load8_s": { "category": "memory", "value": 44, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },	80	"i32.load8_s": { "category": "memory", "value": 44, "return": ["i32"], "parameter": ["addr"], "immediate": [{"name": "flags", "type": "varuint32"}, {"name": "offset", "type": "varuint32"}], "description": "load from memory" },

Return to Bug 219297

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +59 lines
		1	2020-12-08 Dmitry Bezhetskov <dbezhetskov@igalia.com>
		2
		3	[WASM-References] Add table.init
		4	https://bugs.webkit.org/show_bug.cgi?id=219297
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Add support for table.init, elem.drop and new element section
		9	from reference-type proposal:
		10	https://webassembly.github.io/reference-types/core/syntax/instructions.html#table-instructions,
		11	https://webassembly.github.io/reference-types/core/syntax/modules.html#element-segments.
		12	All in one patch because all this stuff are very coupled and ref-types
		13	spec tests require each other to run the its tests, so not to write
		14	hand-crafted tests this is in one PR.
		15
		16	* bytecode/BytecodeList.rb:
		17	* llint/WebAssembly.asm:
		18	* wasm/WasmAirIRGenerator.cpp:
		19	(JSC::Wasm::AirIRGenerator::addTableInit):
		20	(JSC::Wasm::AirIRGenerator::addElemDrop):
		21	* wasm/WasmB3IRGenerator.cpp:
		22	(JSC::Wasm::B3IRGenerator::addTableInit):
		23	(JSC::Wasm::B3IRGenerator::addElemDrop):
		24	* wasm/WasmFormat.h:
		25	(JSC::Wasm::Element::Element):
		26	(JSC::Wasm::Element::length const):
		27	(JSC::Wasm::Element::isPassive const):
		28	* wasm/WasmFunctionParser.h:
		29	(JSC::Wasm::FunctionParser<Context>::parseExpression):
		30	* wasm/WasmInstance.cpp:
		31	(JSC::Wasm::Instance::Instance):
		32	(JSC::Wasm::Instance::elemDrop):
		33	(JSC::Wasm::Instance::elem const):
		34	(JSC::Wasm::Instance::initElementSegment):
		35	(JSC::Wasm::Instance::tableInit):
		36	* wasm/WasmInstance.h:
		37	(JSC::Wasm::Instance::isImportFunction const):
		38	* wasm/WasmLLIntGenerator.cpp:
		39	(JSC::Wasm::LLIntGenerator::addTableInit):
		40	(JSC::Wasm::LLIntGenerator::addElemDrop):
		41	* wasm/WasmModuleInformation.h:
		42	(JSC::Wasm::ModuleInformation::elementCount const):
		43	* wasm/WasmOperations.cpp:
		44	(JSC::Wasm::JSC_DEFINE_JIT_OPERATION):
		45	* wasm/WasmOperations.h:
		46	* wasm/WasmSectionParser.cpp:
		47	(JSC::Wasm::SectionParser::parseElement):
		48	(JSC::Wasm::SectionParser::parseElementSegmentVectorOfExpressions):
		49	(JSC::Wasm::SectionParser::parseElementSegmentVectorOfIndexes):
		50	(JSC::Wasm::SectionParser::parseFuncIndexFromRefExpForElementSection): Deleted.
		51	(JSC::Wasm::SectionParser::parseFuncIndexForElementSection): Deleted.
		52	* wasm/WasmSectionParser.h:
		53	* wasm/WasmSlowPaths.cpp:
		54	(JSC::LLInt::WASM_SLOW_PATH_DECL):
		55	* wasm/WasmSlowPaths.h:
		56	* wasm/js/WebAssemblyModuleRecord.cpp:
		57	(JSC::WebAssemblyModuleRecord::evaluate):
		58	* wasm/wasm.json:
		59
1	2020-12-07 Dmitry Bezhetskov <dbezhetskov@igalia.com>	60	2020-12-07 Dmitry Bezhetskov <dbezhetskov@igalia.com>
2		61
3	[WASM-References] Add support for table.copy	62	[WASM-References] Add support for table.copy

Lines 1587-1592 op :table_set, a/Source/JavaScriptCore/bytecode/BytecodeList.rb_sec1
- a/Source/JavaScriptCore/bytecode/BytecodeList.rb +14 lines
1587	tableIndex: unsigned,	1587	tableIndex: unsigned,
1588	}	1588	}
1589		1589
		1590	op :table_init,
		1591	args: {
		1592	dstOffset: VirtualRegister,
		1593	srcOffset: VirtualRegister,
		1594	length: VirtualRegister,
		1595	elementIndex: unsigned,
		1596	tableIndex: unsigned,
		1597	}
		1598
		1599	op :elem_drop,
		1600	args: {
		1601	elementIndex: unsigned,
		1602	}
		1603
1590	op :table_size,	1604	op :table_size,
1591	args: {	1605	args: {
1592	dst: VirtualRegister,	1606	dst: VirtualRegister,

Lines 260-265 public: a/Source/JavaScriptCore/wasm/WasmAirIRGenerator.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmAirIRGenerator.cpp +35 lines
260	// Tables	260	// Tables
261	PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);	261	PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);
262	PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);	262	PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);
		263	PartialResult WARN_UNUSED_RETURN addTableInit(unsigned, unsigned, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length);
		264	PartialResult WARN_UNUSED_RETURN addElemDrop(unsigned);
263	PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);	265	PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);
264	PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);	266	PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);
265	PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);	267	PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);
Lines 1118-1123 auto AirIRGenerator::addTableSet(unsigned tableIndex, ExpressionType index, Expr a/Source/JavaScriptCore/wasm/WasmAirIRGenerator.cpp_sec2
1118	return { };	1120	return { };
1119	}	1121	}
1120		1122
		1123	auto AirIRGenerator::addTableInit(unsigned elementIndex, unsigned tableIndex, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length) -> PartialResult
		1124	{
		1125	ASSERT(dstOffset.tmp());
		1126	ASSERT(dstOffset.type() == Type::I32);
		1127
		1128	ASSERT(srcOffset.tmp());
		1129	ASSERT(srcOffset.type() == Type::I32);
		1130
		1131	ASSERT(length.tmp());
		1132	ASSERT(length.type() == Type::I32);
		1133
		1134	auto result = tmpForType(Type::I32);
		1135	emitCCall(
		1136	&operationWasmTableInit, result, instanceValue(),
		1137	addConstant(Type::I32, elementIndex),
		1138	addConstant(Type::I32, tableIndex),
		1139	dstOffset, srcOffset, length);
		1140
		1141	emitCheck([&] {
		1142	return Inst(BranchTest32, nullptr, Arg::resCond(MacroAssembler::Zero), result, result);
		1143	}, [=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
		1144	this->emitThrowException(jit, ExceptionType::OutOfBoundsTableAccess);
		1145	});
		1146
		1147	return { };
		1148	}
		1149
		1150	auto AirIRGenerator::addElemDrop(unsigned elementIndex) -> PartialResult
		1151	{
		1152	emitCCall(&operationWasmElemDrop, TypedTmp(), instanceValue(), addConstant(Type::I32, elementIndex));
		1153	return { };
		1154	}
		1155
1121	auto AirIRGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult	1156	auto AirIRGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult
1122	{	1157	{
1123	// FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.	1158	// FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.

Lines 215-220 public: a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp +35 lines
215	// Tables	215	// Tables
216	PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);	216	PartialResult WARN_UNUSED_RETURN addTableGet(unsigned, ExpressionType index, ExpressionType& result);
217	PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);	217	PartialResult WARN_UNUSED_RETURN addTableSet(unsigned, ExpressionType index, ExpressionType value);
		218	PartialResult WARN_UNUSED_RETURN addTableInit(unsigned, unsigned, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length);
		219	PartialResult WARN_UNUSED_RETURN addElemDrop(unsigned);
218	PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);	220	PartialResult WARN_UNUSED_RETURN addTableSize(unsigned, ExpressionType& result);
219	PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);	221	PartialResult WARN_UNUSED_RETURN addTableGrow(unsigned, ExpressionType fill, ExpressionType delta, ExpressionType& result);
220	PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);	222	PartialResult WARN_UNUSED_RETURN addTableFill(unsigned, ExpressionType offset, ExpressionType fill, ExpressionType count);
Lines 744-749 auto B3IRGenerator::addRefFunc(uint32_t index, ExpressionType& result) -> Partia a/Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp_sec2
744	return { };	746	return { };
745	}	747	}
746		748
		749	auto B3IRGenerator::addTableInit(unsigned elementIndex, unsigned tableIndex, ExpressionType dstOffset, ExpressionType srcOffset, ExpressionType length) -> PartialResult
		750	{
		751	auto result = m_currentBlock->appendNew<CCallValue>(
		752	m_proc, toB3Type(I32), origin(),
		753	m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmTableInit)),
		754	instanceValue(),
		755	m_currentBlock->appendNew<Const32Value>(m_proc, origin(), elementIndex),
		756	m_currentBlock->appendNew<Const32Value>(m_proc, origin(), tableIndex),
		757	dstOffset, srcOffset, length);
		758
		759	{
		760	CheckValue* check = m_currentBlock->appendNew<CheckValue>(m_proc, Check, origin(),
		761	m_currentBlock->appendNew<Value>(m_proc, Equal, origin(), result, m_currentBlock->appendNew<Const32Value>(m_proc, origin(), 0)));
		762
		763	check->setGenerator([=] (CCallHelpers& jit, const B3::StackmapGenerationParams&) {
		764	this->emitExceptionCheck(jit, ExceptionType::OutOfBoundsTableAccess);
		765	});
		766	}
		767
		768	return { };
		769	}
		770
		771	auto B3IRGenerator::addElemDrop(unsigned elementIndex) -> PartialResult
		772	{
		773	m_currentBlock->appendNew<CCallValue>(
		774	m_proc, B3::Void, origin(),
		775	m_currentBlock->appendNew<ConstPtrValue>(m_proc, origin(), tagCFunction<OperationPtrTag>(operationWasmElemDrop)),
		776	instanceValue(),
		777	m_currentBlock->appendNew<Const32Value>(m_proc, origin(), elementIndex));
		778
		779	return { };
		780	}
		781
747	auto B3IRGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult	782	auto B3IRGenerator::addTableSize(unsigned tableIndex, ExpressionType& result) -> PartialResult
748	{	783	{
749	// FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.	784	// FIXME: Emit this inline <https://bugs.webkit.org/show_bug.cgi?id=198506>.

Lines 238-257 struct Element { a/Source/JavaScriptCore/wasm/WasmFormat.h_sec1
- a/Source/JavaScriptCore/wasm/WasmFormat.h -4 / +11 lines
238	Declared,	238	Declared,
239	};	239	};
240		240
241	Element(Element::Kind kind, TableElementType elementType, uint32_t tableIndex, Optional<I32InitExpr> initExpr)	241	Element(Element::Kind kind, TableElementType elementType, Optional<uint32_t> tableIndex, Optional<I32InitExpr> initExpr)
242	: kind(kind)	242	: kind(kind)
243	, elementType(elementType)	243	, elementType(elementType)
244	, tableIndex(tableIndex)	244	, tableIndexIfActive(WTFMove(tableIndex))
245	, offsetIfActive(initExpr)	245	, offsetIfActive(WTFMove(initExpr))
246	{ }	246	{ }
247		247
		248	Element(Element::Kind kind, TableElementType elemType)
		249	: Element(kind, elemType, WTF::nullopt, WTF::nullopt)
		250	{ }
		251
		252	uint32_t length() const { return functionIndices.size(); }
		253
248	bool isActive() const { return kind == Kind::Active; }	254	bool isActive() const { return kind == Kind::Active; }
		255	bool isPassive() const { return kind == Kind::Passive; }
249		256
250	static bool isNullFuncIndex(uint32_t idx) { return idx == nullFuncIndex; }	257	static bool isNullFuncIndex(uint32_t idx) { return idx == nullFuncIndex; }
251		258
252	Kind kind;	259	Kind kind;
253	TableElementType elementType;	260	TableElementType elementType;
254	uint32_t tableIndex;	261	Optional<uint32_t> tableIndexIfActive;
255	Optional<I32InitExpr> offsetIfActive;	262	Optional<I32InitExpr> offsetIfActive;
256		263
257	// Index may be nullFuncIndex.	264	// Index may be nullFuncIndex.

Lines 135-140 private: a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec1
- a/Source/JavaScriptCore/wasm/WasmFunctionParser.h -17 / +136 lines
135	PartialResult WARN_UNUSED_RETURN atomicNotify(ExtAtomicOpType);	135	PartialResult WARN_UNUSED_RETURN atomicNotify(ExtAtomicOpType);
136	PartialResult WARN_UNUSED_RETURN atomicFence(ExtAtomicOpType);	136	PartialResult WARN_UNUSED_RETURN atomicFence(ExtAtomicOpType);
137		137
		138	PartialResult WARN_UNUSED_RETURN parseTableIndex(unsigned&);
		139	PartialResult WARN_UNUSED_RETURN parseElementIndex(unsigned&);
		140
		141	struct TableInitImmediates {
		142	unsigned elementIndex;
		143	unsigned tableIndex;
		144	};
		145	PartialResult WARN_UNUSED_RETURN parseTableInitImmediates(TableInitImmediates&);
		146
		147	struct TableCopyImmediates {
		148	unsigned srcTableIndex;
		149	unsigned dstTableIndex;
		150	};
		151	PartialResult WARN_UNUSED_RETURN parseTableCopyImmediates(TableCopyImmediates&);
		152
138	#define WASM_TRY_ADD_TO_CONTEXT(add_expression) WASM_FAIL_IF_HELPER_FAILS(m_context.add_expression)	153	#define WASM_TRY_ADD_TO_CONTEXT(add_expression) WASM_FAIL_IF_HELPER_FAILS(m_context.add_expression)
139		154
140	template <typename ...Args>	155	template <typename ...Args>
Lines 479-484 auto FunctionParser<Context>::atomicFence(ExtAtomicOpType op) -> PartialResult a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec2
479	return { };	494	return { };
480	}	495	}
481		496
		497	template<typename Context>
		498	auto FunctionParser<Context>::parseTableIndex(unsigned& result) -> PartialResult
		499	{
		500	unsigned tableIndex;
		501	WASM_PARSER_FAIL_IF(!parseVarUInt32(tableIndex), "can't parse table index");
		502	WASM_VALIDATOR_FAIL_IF(tableIndex >= m_info.tableCount(), "table index ", tableIndex, " is invalid, limit is ", m_info.tableCount());
		503	result = tableIndex;
		504	return { };
		505	}
		506
		507	template<typename Context>
		508	auto FunctionParser<Context>::parseElementIndex(unsigned& result) -> PartialResult
		509	{
		510	unsigned elementIndex;
		511	WASM_PARSER_FAIL_IF(!parseVarUInt32(elementIndex), "can't parse element index");
		512	WASM_VALIDATOR_FAIL_IF(elementIndex >= m_info.elementCount(), "element index ", elementIndex, " is invalid, limit is ", m_info.elementCount());
		513	result = elementIndex;
		514	return { };
		515	}
		516
		517	template<typename Context>
		518	auto FunctionParser<Context>::parseTableInitImmediates(TableInitImmediates& result) -> PartialResult
		519	{
		520	unsigned elementIndex;
		521	WASM_FAIL_IF_HELPER_FAILS(parseElementIndex(elementIndex));
		522
		523	unsigned tableIndex;
		524	WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
		525
		526	result.elementIndex = elementIndex;
		527	result.tableIndex = tableIndex;
		528
		529	return { };
		530	}
		531
		532	template<typename Context>
		533	auto FunctionParser<Context>::parseTableCopyImmediates(TableCopyImmediates& result) -> PartialResult
		534	{
		535	unsigned dstTableIndex;
		536	WASM_PARSER_FAIL_IF(!parseVarUInt32(dstTableIndex), "can't parse destination table index");
		537	WASM_VALIDATOR_FAIL_IF(dstTableIndex >= m_info.tableCount(), "table index ", dstTableIndex, " is invalid, limit is ", m_info.tableCount());
		538
		539	unsigned srcTableIndex;
		540	WASM_PARSER_FAIL_IF(!parseVarUInt32(srcTableIndex), "can't parse source table index");
		541	WASM_VALIDATOR_FAIL_IF(srcTableIndex >= m_info.tableCount(), "table index ", srcTableIndex, " is invalid, limit is ", m_info.tableCount());
		542
		543	result.dstTableIndex = dstTableIndex;
		544	result.srcTableIndex = srcTableIndex;
		545
		546	return { };
		547	}
		548
482	template<typename Context>	549	template<typename Context>
483	auto FunctionParser<Context>::checkBranchTarget(const ControlType& target) -> PartialResult	550	auto FunctionParser<Context>::checkBranchTarget(const ControlType& target) -> PartialResult
484	{	551	{
Lines 611-620 FOR_EACH_WASM_MEMORY_STORE_OP(CREATE_CASE) a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec3
611	WASM_PARSER_FAIL_IF(!parseUInt8(extOp), "can't parse table extended opcode");	678	WASM_PARSER_FAIL_IF(!parseUInt8(extOp), "can't parse table extended opcode");
612		679
613	switch (static_cast<ExtTableOpType>(extOp)) {	680	switch (static_cast<ExtTableOpType>(extOp)) {
		681	case ExtTableOpType::TableInit: {
		682	TableInitImmediates immediates;
		683	WASM_FAIL_IF_HELPER_FAILS(parseTableInitImmediates(immediates));
		684
		685	TypedExpression dstOffset;
		686	TypedExpression srcOffset;
		687	TypedExpression lenght;
		688	WASM_TRY_POP_EXPRESSION_STACK_INTO(lenght, "table.init");
		689	WASM_TRY_POP_EXPRESSION_STACK_INTO(srcOffset, "table.init");
		690	WASM_TRY_POP_EXPRESSION_STACK_INTO(dstOffset, "table.init");
		691
		692	WASM_VALIDATOR_FAIL_IF(I32 != dstOffset.type(), "table.init dst_offset to type ", dstOffset.type(), " expected ", I32);
		693	WASM_VALIDATOR_FAIL_IF(I32 != srcOffset.type(), "table.init src_offset to type ", srcOffset.type(), " expected ", I32);
		694	WASM_VALIDATOR_FAIL_IF(I32 != lenght.type(), "table.init length to type ", lenght.type(), " expected ", I32);
		695
		696	WASM_TRY_ADD_TO_CONTEXT(addTableInit(immediates.elementIndex, immediates.tableIndex, dstOffset, srcOffset, lenght));
		697	break;
		698	}
		699	case ExtTableOpType::ElemDrop: {
		700	unsigned elementIndex;
		701	WASM_FAIL_IF_HELPER_FAILS(parseElementIndex(elementIndex));
		702
		703	WASM_TRY_ADD_TO_CONTEXT(addElemDrop(elementIndex));
		704	break;
		705	}
614	case ExtTableOpType::TableSize: {	706	case ExtTableOpType::TableSize: {
615	unsigned tableIndex;	707	unsigned tableIndex;
616	WASM_PARSER_FAIL_IF(!parseVarUInt32(tableIndex), "can't parse table index");	708	WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
617	WASM_VALIDATOR_FAIL_IF(tableIndex >= m_info.tableCount(), "table index ", tableIndex, " is invalid, limit is ", m_info.tableCount());
618		709
619	ExpressionType result;	710	ExpressionType result;
620	WASM_TRY_ADD_TO_CONTEXT(addTableSize(tableIndex, result));	711	WASM_TRY_ADD_TO_CONTEXT(addTableSize(tableIndex, result));
Lines 623-630 FOR_EACH_WASM_MEMORY_STORE_OP(CREATE_CASE) a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec4
623	}	714	}
624	case ExtTableOpType::TableGrow: {	715	case ExtTableOpType::TableGrow: {
625	unsigned tableIndex;	716	unsigned tableIndex;
626	WASM_PARSER_FAIL_IF(!parseVarUInt32(tableIndex), "can't parse table index");	717	WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
627	WASM_VALIDATOR_FAIL_IF(tableIndex >= m_info.tableCount(), "table index ", tableIndex, " is invalid, limit is ", m_info.tableCount());
628		718
629	TypedExpression fill;	719	TypedExpression fill;
630	TypedExpression delta;	720	TypedExpression delta;
Lines 641-648 FOR_EACH_WASM_MEMORY_STORE_OP(CREATE_CASE) a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec5
641	}	731	}
642	case ExtTableOpType::TableFill: {	732	case ExtTableOpType::TableFill: {
643	unsigned tableIndex;	733	unsigned tableIndex;
644	WASM_PARSER_FAIL_IF(!parseVarUInt32(tableIndex), "can't parse table index");	734	WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
645	WASM_VALIDATOR_FAIL_IF(tableIndex >= m_info.tableCount(), "table index ", tableIndex, " is invalid, limit is ", m_info.tableCount());
646		735
647	TypedExpression offset, fill, count;	736	TypedExpression offset, fill, count;
648	WASM_TRY_POP_EXPRESSION_STACK_INTO(count, "table.fill");	737	WASM_TRY_POP_EXPRESSION_STACK_INTO(count, "table.fill");
Lines 657-672 FOR_EACH_WASM_MEMORY_STORE_OP(CREATE_CASE) a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec6
657	break;	746	break;
658	}	747	}
659	case ExtTableOpType::TableCopy: {	748	case ExtTableOpType::TableCopy: {
660	unsigned dstTableIndex;	749	TableCopyImmediates immediates;
661	WASM_PARSER_FAIL_IF(!parseVarUInt32(dstTableIndex), "can't parse destination table index");	750	WASM_FAIL_IF_HELPER_FAILS(parseTableCopyImmediates(immediates));
662	WASM_VALIDATOR_FAIL_IF(dstTableIndex >= m_info.tableCount(), "table index ", dstTableIndex, " is invalid, limit is ", m_info.tableCount());
663
664	unsigned srcTableIndex;
665	WASM_PARSER_FAIL_IF(!parseVarUInt32(srcTableIndex), "can't parse source table index");
666	WASM_VALIDATOR_FAIL_IF(srcTableIndex >= m_info.tableCount(), "table index ", srcTableIndex, " is invalid, limit is ", m_info.tableCount());
667		751
668	const auto srcType = m_info.table(srcTableIndex).wasmType();	752	const auto srcType = m_info.table(immediates.srcTableIndex).wasmType();
669	const auto dstType = m_info.table(dstTableIndex).wasmType();	753	const auto dstType = m_info.table(immediates.dstTableIndex).wasmType();
670	WASM_VALIDATOR_FAIL_IF(srcType != dstType, "type mismatch at table.copy. got ", srcType, " and ", dstType);	754	WASM_VALIDATOR_FAIL_IF(srcType != dstType, "type mismatch at table.copy. got ", srcType, " and ", dstType);
671		755
672	TypedExpression dstOffset;	756	TypedExpression dstOffset;
Lines 680-686 FOR_EACH_WASM_MEMORY_STORE_OP(CREATE_CASE) a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec7
680	WASM_VALIDATOR_FAIL_IF(I32 != srcOffset.type(), "table.copy src_offset to type ", srcOffset.type(), " expected ", I32);	764	WASM_VALIDATOR_FAIL_IF(I32 != srcOffset.type(), "table.copy src_offset to type ", srcOffset.type(), " expected ", I32);
681	WASM_VALIDATOR_FAIL_IF(I32 != length.type(), "table.copy length to type ", length.type(), " expected ", I32);	765	WASM_VALIDATOR_FAIL_IF(I32 != length.type(), "table.copy length to type ", length.type(), " expected ", I32);
682		766
683	WASM_TRY_ADD_TO_CONTEXT(addTableCopy(dstTableIndex, srcTableIndex, dstOffset, srcOffset, length));	767	WASM_TRY_ADD_TO_CONTEXT(addTableCopy(immediates.dstTableIndex, immediates.srcTableIndex, dstOffset, srcOffset, length));
684	break;	768	break;
685	}	769	}
686	default:	770	default:
Lines 1223-1229 auto FunctionParser<Context>::parseUnreachableExpression() -> PartialResult a/Source/JavaScriptCore/wasm/WasmFunctionParser.h_sec8
1223	return { };	1307	return { };
1224	}	1308	}
1225		1309
1226	case ExtTable:	1310	case ExtTable: {
		1311	WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");
		1312	uint8_t extOp;
		1313	WASM_PARSER_FAIL_IF(!parseUInt8(extOp), "can't parse table extended opcode");
		1314
		1315	switch (static_cast<ExtTableOpType>(extOp)) {
		1316	case ExtTableOpType::TableInit: {
		1317	TableInitImmediates immediates;
		1318	WASM_FAIL_IF_HELPER_FAILS(parseTableInitImmediates(immediates));
		1319	return { };
		1320	}
		1321	case ExtTableOpType::ElemDrop: {
		1322	unsigned elementIndex;
		1323	WASM_FAIL_IF_HELPER_FAILS(parseElementIndex(elementIndex));
		1324	return { };
		1325	}
		1326	case ExtTableOpType::TableSize:
		1327	case ExtTableOpType::TableGrow:
		1328	case ExtTableOpType::TableFill: {
		1329	unsigned tableIndex;
		1330	WASM_FAIL_IF_HELPER_FAILS(parseTableIndex(tableIndex));
		1331	return { };
		1332	}
		1333	case ExtTableOpType::TableCopy: {
		1334	TableCopyImmediates immediates;
		1335	WASM_FAIL_IF_HELPER_FAILS(parseTableCopyImmediates(immediates));
		1336	return { };
		1337	}
		1338	default:
		1339	WASM_PARSER_FAIL_IF(true, "invalid extended table op ", extOp);
		1340	break;
		1341	}
		1342
		1343	return { };
		1344	}
		1345
1227	case TableGet:	1346	case TableGet:
1228	case TableSet: {	1347	case TableSet: {
1229	unsigned tableIndex;	1348	unsigned tableIndex;

Lines 689-694 JSC_DEFINE_JIT_OPERATION(operationSetWasmTableElement, bool, (Instance* instance a/Source/JavaScriptCore/wasm/WasmOperations.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmOperations.cpp +38 lines
689	return setWasmTableElement(instance, tableIndex, signedIndex, encValue);	689	return setWasmTableElement(instance, tableIndex, signedIndex, encValue);
690	}	690	}
691		691
		692	JSC_DEFINE_JIT_OPERATION(operationWasmTableInit, bool, (Instance* instance, unsigned elementIndex, unsigned tableIndex, int32_t dstOffset, int32_t srcOffset, int32_t length))
		693	{
		694	ASSERT(elementIndex < instance->module().moduleInformation().elementCount());
		695	ASSERT(tableIndex < instance->module().moduleInformation().tableCount());
		696
		697	if ((srcOffset < 0) \|\| (dstOffset < 0) \|\| (length < 0))
		698	return false;
		699
		700	Checked<uint32_t, RecordOverflow> lastSrcElementIndexChecked = static_cast<uint32_t>(srcOffset);
		701	lastSrcElementIndexChecked += static_cast<uint32_t>(length);
		702
		703	uint32_t lastSrcElementIndex;
		704	if (lastSrcElementIndexChecked.safeGet(lastSrcElementIndex) == CheckedState::DidOverflow)
		705	return false;
		706
		707	if (!instance->elementAt(elementIndex) \|\| lastSrcElementIndex > instance->elementAt(elementIndex)->length())
		708	return false;
		709
		710	Checked<uint32_t, RecordOverflow> lastDstElementIndexChecked = static_cast<uint32_t>(dstOffset);
		711	lastDstElementIndexChecked += static_cast<uint32_t>(length);
		712
		713	uint32_t lastDstElementIndex;
		714	if (lastDstElementIndexChecked.safeGet(lastDstElementIndex) == CheckedState::DidOverflow)
		715	return false;
		716
		717	if (lastDstElementIndex > instance->table(tableIndex)->length())
		718	return false;
		719
		720	instance->tableInit(dstOffset, srcOffset, length, elementIndex, tableIndex);
		721	return true;
		722	}
		723
		724	JSC_DEFINE_JIT_OPERATION(operationWasmElemDrop, void, (Instance* instance, unsigned elementIndex))
		725	{
		726	ASSERT(elementIndex < instance->module().moduleInformation().elementCount());
		727	instance->elemDrop(elementIndex);
		728	}
		729
692	JSC_DEFINE_JIT_OPERATION(operationWasmTableGrow, int32_t, (Instance* instance, unsigned tableIndex, EncodedJSValue fill, int32_t delta))	730	JSC_DEFINE_JIT_OPERATION(operationWasmTableGrow, int32_t, (Instance* instance, unsigned tableIndex, EncodedJSValue fill, int32_t delta))
693	{	731	{
694	ASSERT(tableIndex < instance->module().moduleInformation().tableCount());	732	ASSERT(tableIndex < instance->module().moduleInformation().tableCount());

Lines 402-413 auto SectionParser::parseElement() -> PartialResult a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp -70 / +66 lines
402	Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));	402	Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));
403	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");	403	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
404		404
405	for (uint32_t index = 0; index < indexCount; ++index) {	405	WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfIndexes(element.functionIndices, indexCount, elementNum));
406	uint32_t funcIndex;
407	WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexForElementSection(funcIndex, elementNum, index));
408	element.functionIndices.uncheckedAppend(funcIndex);
409	}
410
411	m_info->elements.uncheckedAppend(WTFMove(element));	406	m_info->elements.uncheckedAppend(WTFMove(element));
412	break;	407	break;
413	}	408	}
Lines 419-433 auto SectionParser::parseElement() -> PartialResult a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp_sec2
419		414
420	uint32_t indexCount;	415	uint32_t indexCount;
421	WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));	416	WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));
		417	Element element(Element::Kind::Passive, TableElementType::Funcref);
		418	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
422		419
423	// We don't have the table.init instruction to use passive element segments,	420	WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfIndexes(element.functionIndices, indexCount, elementNum));
424	// but we need to parse them for the table.copy spec test, so we just skip them.	421	m_info->elements.uncheckedAppend(WTFMove(element));
425	// Add support for passive element segments and table.init.
426	// FIXME: https://bugs.webkit.org/show_bug.cgi?id=219297
427	for (uint32_t index = 0; index < indexCount; ++index) {
428	uint32_t funcIndex;
429	WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexForElementSection(funcIndex, elementNum, index));
430	}
431	break;	422	break;
432	}	423	}
433	case 0x02: {	424	case 0x02: {
Lines 448-467 auto SectionParser::parseElement() -> PartialResult a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp_sec3
448	Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));	439	Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));
449	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");	440	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
450		441
451	for (unsigned index = 0; index < indexCount; ++index) {	442	WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfIndexes(element.functionIndices, indexCount, elementNum));
452	uint32_t funcIndex;
453	WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexForElementSection(funcIndex, elementNum, index));
454	element.functionIndices.uncheckedAppend(funcIndex);
455	}
456
457	m_info->elements.uncheckedAppend(WTFMove(element));	443	m_info->elements.uncheckedAppend(WTFMove(element));
458	break;	444	break;
459	}	445	}
460	case 0x03: {	446	case 0x03: {
461	WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");	447	WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");
462	WASM_PARSER_FAIL_IF(true, "unsupported ", elementNum, "th Element reserved byte");	448
463	// Add support for declarative element segments.	449	uint8_t elementKind;
464	// FIXME: https://bugs.webkit.org/show_bug.cgi?id=219385	450	WASM_FAIL_IF_HELPER_FAILS(parseElementKind(elementKind));
		451
		452	uint32_t indexCount;
		453	WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));
		454	Element element(Element::Kind::Declared, TableElementType::Funcref);
		455	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
		456
		457	WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfIndexes(element.functionIndices, indexCount, elementNum));
		458	m_info->elements.uncheckedAppend(WTFMove(element));
465	break;	459	break;
466	}	460	}
467	case 0x04: {	461	case 0x04: {
Lines 479-490 auto SectionParser::parseElement() -> PartialResult a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp_sec4
479	Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));	473	Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));
480	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");	474	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
481		475
482	for (unsigned index = 0; index < indexCount; ++index) {	476	WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfExpressions(element.functionIndices, indexCount, elementNum));
483	uint32_t funcIndex;
484	WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexFromRefExpForElementSection(funcIndex, elementNum, index));
485	element.functionIndices.uncheckedAppend(funcIndex);
486	}
487
488	m_info->elements.uncheckedAppend(WTFMove(element));	477	m_info->elements.uncheckedAppend(WTFMove(element));
489	break;	478	break;
490	}	479	}
Lines 492-511 auto SectionParser::parseElement() -> PartialResult a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp_sec5
492	WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");	481	WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");
493	Type refType;	482	Type refType;
494	WASM_PARSER_FAIL_IF(!parseRefType(refType), "can't parse reftype in elem section");	483	WASM_PARSER_FAIL_IF(!parseRefType(refType), "can't parse reftype in elem section");
495	WASM_PARSER_FAIL_IF(refType == Externref, "reftype in element section should be funcref");	484	WASM_PARSER_FAIL_IF(refType != Funcref, "reftype in element section should be funcref");
496		485
497	uint32_t indexCount;	486	uint32_t indexCount;
498	WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));	487	WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));
499		488
500	// We don't have the table.init instruction to use passive element segments,	489	Element element(Element::Kind::Passive, TableElementType::Funcref);
501	// but we need to parse them for the table.copy spec test, so we just skip them.	490	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
502	// Add support for passive element segments and table.init.
503	// FIXME: https://bugs.webkit.org/show_bug.cgi?id=219297
504	for (unsigned index = 0; index < indexCount; ++index) {
505	uint32_t funcIndex;
506	WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexFromRefExpForElementSection(funcIndex, elementNum, index));
507	}
508		491
		492	WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfExpressions(element.functionIndices, indexCount, elementNum));
		493	m_info->elements.uncheckedAppend(WTFMove(element));
509	break;	494	break;
510	}	495	}
511	case 0x06: {	496	case 0x06: {
Lines 529-548 auto SectionParser::parseElement() -> PartialResult a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp_sec6
529	Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));	514	Element element(Element::Kind::Active, TableElementType::Funcref, tableIndex, WTFMove(initExpr));
530	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");	515	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
531		516
532	for (unsigned index = 0; index < indexCount; ++index) {	517	WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfExpressions(element.functionIndices, indexCount, elementNum));
533	uint32_t funcIndex;
534	WASM_FAIL_IF_HELPER_FAILS(parseFuncIndexFromRefExpForElementSection(funcIndex, elementNum, index));
535	element.functionIndices.uncheckedAppend(funcIndex);
536	}
537
538	m_info->elements.uncheckedAppend(WTFMove(element));	518	m_info->elements.uncheckedAppend(WTFMove(element));
539	break;	519	break;
540	}	520	}
541	case 0x07: {	521	case 0x07: {
542	WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");	522	WASM_PARSER_FAIL_IF(!Options::useWebAssemblyReferences(), "references are not enabled");
543	WASM_PARSER_FAIL_IF(true, "unsupported ", elementNum, "th Element reserved byte");	523
544	// Add support for declarative element segments.	524	Type refType;
545	// FIXME: https://bugs.webkit.org/show_bug.cgi?id=219385	525	WASM_PARSER_FAIL_IF(!parseRefType(refType), "can't parse reftype in elem section");
		526	WASM_PARSER_FAIL_IF(refType != Funcref, "reftype in element section should be funcref");
		527
		528	uint32_t indexCount;
		529	WASM_FAIL_IF_HELPER_FAILS(parseIndexCountForElementSection(indexCount, elementNum));
		530
		531	Element element(Element::Kind::Declared, TableElementType::Funcref);
		532	WASM_PARSER_FAIL_IF(!element.functionIndices.tryReserveCapacity(indexCount), "can't allocate memory for ", indexCount, " Element indices");
		533
		534	WASM_FAIL_IF_HELPER_FAILS(parseElementSegmentVectorOfExpressions(element.functionIndices, indexCount, elementNum));
		535	m_info->elements.uncheckedAppend(WTFMove(element));
546	break;	536	break;
547	}	537	}
548	default:	538	default:
Lines 679-714 auto SectionParser::parseIndexCountForElementSection(uint32_t& resultIndexCount, a/Source/JavaScriptCore/wasm/WasmSectionParser.cpp_sec7
679	return { };	669	return { };
680	}	670	}
681		671
682	auto SectionParser::parseFuncIndexFromRefExpForElementSection(uint32_t& resultFuncIndex, const unsigned elementNum, const unsigned index) -> PartialResult	672	auto SectionParser::parseElementSegmentVectorOfExpressions(Vector<uint32_t>& result, const unsigned indexCount, const unsigned elementNum) -> PartialResult
683	{	673	{
684	uint8_t opcode;	674	for (uint32_t index = 0; index < indexCount; ++index) {
685	WASM_PARSER_FAIL_IF(!parseUInt8(opcode), "can't get opcode for exp in element section's ", elementNum, "th element's ", index, "th index");	675	uint8_t opcode;
686	WASM_PARSER_FAIL_IF((opcode != RefFunc) && (opcode != RefNull), "opcode for exp in element section's should be either ref.func or ref.null ", elementNum, "th element's ", index, "th index");	676	WASM_PARSER_FAIL_IF(!parseUInt8(opcode), "can't get opcode for exp in element section's ", elementNum, "th element's ", index, "th index");
687		677	WASM_PARSER_FAIL_IF((opcode != RefFunc) && (opcode != RefNull), "opcode for exp in element section's should be either ref.func or ref.null ", elementNum, "th element's ", index, "th index");
688	if (opcode == RefFunc) {	678
689	uint32_t funcIndex;	679	uint32_t functionIndex;
690	WASM_PARSER_FAIL_IF(!parseVarUInt32(funcIndex), "can't get Element section's ", elementNum, "th element's ", index, "th index");	680	if (opcode == RefFunc) {
691	WASM_PARSER_FAIL_IF(funcIndex >= m_info->functionIndexSpaceSize(), "Element section's ", elementNum, "th element's ", index, "th index is ", funcIndex, " which exceeds the function index space size of ", m_info->functionIndexSpaceSize());	681	WASM_PARSER_FAIL_IF(!parseVarUInt32(functionIndex), "can't get Element section's ", elementNum, "th element's ", index, "th index");
692	resultFuncIndex = funcIndex;	682	WASM_PARSER_FAIL_IF(functionIndex >= m_info->functionIndexSpaceSize(), "Element section's ", elementNum, "th element's ", index, "th index is ", functionIndex, " which exceeds the function index space size of ", m_info->functionIndexSpaceSize());
693	} else {	683	} else {
694	Type typeOfNull;	684	Type typeOfNull;
695	WASM_PARSER_FAIL_IF(!parseRefType(typeOfNull), "ref.null type must be a func type in elem section");	685	WASM_PARSER_FAIL_IF(!parseRefType(typeOfNull), "ref.null type must be a func type in elem section");
696	WASM_PARSER_FAIL_IF(typeOfNull != Funcref, "ref.null extern is forbidden in element section's, ", elementNum, "th element's ", index, "th index");	686	WASM_PARSER_FAIL_IF(typeOfNull != Funcref, "ref.null extern is forbidden in element section's, ", elementNum, "th element's ", index, "th index");
697	resultFuncIndex = Element::nullFuncIndex;	687	functionIndex = Element::nullFuncIndex;
698	}	688	}
699		689
700	WASM_PARSER_FAIL_IF(!parseUInt8(opcode), "can't get opcode for exp end in element section's ", elementNum, "th element's ", index, "th index");	690	WASM_PARSER_FAIL_IF(!parseUInt8(opcode), "can't get opcode for exp end in element section's ", elementNum, "th element's ", index, "th index");
701	WASM_PARSER_FAIL_IF(opcode != End, "malformed expr in element section's", elementNum, "th element's ", index, "th index");	691	WASM_PARSER_FAIL_IF(opcode != End, "malformed expr in element section's", elementNum, "th element's ", index, "th index");
		692
		693	result.uncheckedAppend(functionIndex);
		694	}
702		695
703	return { };	696	return { };
704	}	697	}
705		698
706	auto SectionParser::parseFuncIndexForElementSection(uint32_t& resultFuncIndex, const unsigned elementNum, const unsigned index) -> PartialResult	699	auto SectionParser::parseElementSegmentVectorOfIndexes(Vector<uint32_t>& result, const unsigned indexCount, const unsigned elementNum) -> PartialResult
707	{	700	{
708	uint32_t funcIndex;	701	for (uint32_t index = 0; index < indexCount; ++index) {
709	WASM_PARSER_FAIL_IF(!parseVarUInt32(funcIndex), "can't get Element section's ", elementNum, "th element's ", index, "th index");	702	uint32_t functionIndex;
710	WASM_PARSER_FAIL_IF(funcIndex >= m_info->functionIndexSpaceSize(), "Element section's ", elementNum, "th element's ", index, "th index is ", funcIndex, " which exceeds the function index space size of ", m_info->functionIndexSpaceSize());	703	WASM_PARSER_FAIL_IF(!parseVarUInt32(functionIndex), "can't get Element section's ", elementNum, "th element's ", index, "th index");
711	resultFuncIndex = funcIndex;	704	WASM_PARSER_FAIL_IF(functionIndex >= m_info->functionIndexSpaceSize(), "Element section's ", elementNum, "th element's ", index, "th index is ", functionIndex, " which exceeds the function index space size of ", m_info->functionIndexSpaceSize());
		705
		706	result.uncheckedAppend(functionIndex);
		707	}
712		708
713	return { };	709	return { };
714	}	710	}

Lines 71-78 private: a/Source/JavaScriptCore/wasm/WasmSectionParser.h_sec1
- a/Source/JavaScriptCore/wasm/WasmSectionParser.h -2 / +2 lines
71	PartialResult WARN_UNUSED_RETURN parseI32InitExpr(Optional<I32InitExpr>&);	71	PartialResult WARN_UNUSED_RETURN parseI32InitExpr(Optional<I32InitExpr>&);
72	PartialResult WARN_UNUSED_RETURN parseElementKind(uint8_t& elementKind);	72	PartialResult WARN_UNUSED_RETURN parseElementKind(uint8_t& elementKind);
73	PartialResult WARN_UNUSED_RETURN parseIndexCountForElementSection(uint32_t&, const unsigned);	73	PartialResult WARN_UNUSED_RETURN parseIndexCountForElementSection(uint32_t&, const unsigned);
74	PartialResult WARN_UNUSED_RETURN parseFuncIndexFromRefExpForElementSection(uint32_t&, const unsigned, const unsigned);	74	PartialResult WARN_UNUSED_RETURN parseElementSegmentVectorOfExpressions(Vector<uint32_t>&, const unsigned, const unsigned);
75	PartialResult WARN_UNUSED_RETURN parseFuncIndexForElementSection(uint32_t&, const unsigned, const unsigned);	75	PartialResult WARN_UNUSED_RETURN parseElementSegmentVectorOfIndexes(Vector<uint32_t>&, const unsigned, const unsigned);
76		76
77	size_t m_offsetInSource;	77	size_t m_offsetInSource;
78	Ref<ModuleInformation> m_info;	78	Ref<ModuleInformation> m_info;

Lines 316-321 WASM_SLOW_PATH_DECL(table_set) a/Source/JavaScriptCore/wasm/WasmSlowPaths.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmSlowPaths.cpp +20 lines
316	WASM_END();	316	WASM_END();
317	}	317	}
318		318
		319	WASM_SLOW_PATH_DECL(table_init)
		320	{
		321	auto instruction = pc->as<WasmTableInit, WasmOpcodeTraits>();
		322	int32_t dstOffset = READ(instruction.m_dstOffset).unboxedInt32();
		323	int32_t srcOffset = READ(instruction.m_srcOffset).unboxedInt32();
		324	int32_t length = READ(instruction.m_length).unboxedInt32();
		325	if (!Wasm::operationWasmTableInit(instance, instruction.m_elementIndex, instruction.m_tableIndex, dstOffset, srcOffset, length))
		326	WASM_THROW(Wasm::ExceptionType::OutOfBoundsTableAccess);
		327	WASM_END();
		328	}
		329
		330	WASM_SLOW_PATH_DECL(elem_drop)
		331	{
		332	UNUSED_PARAM(callFrame);
		333
		334	auto instruction = pc->as<WasmElemDrop, WasmOpcodeTraits>();
		335	Wasm::operationWasmElemDrop(instance, instruction.m_elementIndex);
		336	WASM_END();
		337	}
		338
319	WASM_SLOW_PATH_DECL(table_size)	339	WASM_SLOW_PATH_DECL(table_size)
320	{	340	{
321	auto instruction = pc->as<WasmTableSize, WasmOpcodeTraits>();	341	auto instruction = pc->as<WasmTableSize, WasmOpcodeTraits>();

Lines 544-569 JSValue WebAssemblyModuleRecord::evaluate(JSGlobalObject* globalObject) a/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp_sec1
- a/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp -12 / +10 lines
544		544
545	Optional<JSValue> exception;	545	Optional<JSValue> exception;
546		546
547	auto forEachElement = [&] (auto fn) {	547	auto forEachActiveElement = [&] (auto fn) {
548	for (const Wasm::Element& element : moduleInformation.elements) {	548	for (const Wasm::Element& element : moduleInformation.elements) {
		549	if (!element.isActive())
		550	continue;
		551
549	// It should be a validation error to have any elements without a table.	552	// It should be a validation error to have any elements without a table.
550	// Also, it could be that a table wasn't imported, or that the table	553	// Also, it could be that a table wasn't imported, or that the table
551	// imported wasn't compatible. However, those should error out before	554	// imported wasn't compatible. However, those should error out before
552	// getting here.	555	// getting here.
553	ASSERT(!!m_instance->table(element.tableIndex));	556	ASSERT(!!m_instance->table(*element.tableIndexIfActive));
554
555	if (!element.functionIndices.size())
556	continue;
557
558	if (!element.isActive())
559	continue;
560		557
561	const auto& offset = *element.offsetIfActive;	558	const auto& offset = *element.offsetIfActive;
562	const uint32_t elementIndex = offset.isGlobalImport()	559	const uint32_t elementIndex = offset.isGlobalImport()
563	? static_cast<uint32_t>(m_instance->instance().loadI32Global(offset.globalImportIndex()))	560	? static_cast<uint32_t>(m_instance->instance().loadI32Global(offset.globalImportIndex()))
564	: offset.constValue();	561	: offset.constValue();
565		562
566	fn(element, element.tableIndex, elementIndex);	563	fn(element, *element.tableIndexIfActive, elementIndex);
567		564
568	if (exception)	565	if (exception)
569	break;	566	break;
Lines 588-595 JSValue WebAssemblyModuleRecord::evaluate(JSGlobalObject* globalObject) a/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp_sec2
588	};	585	};
589		586
590	// Validation of all element ranges comes before all Table and Memory initialization.	587	// Validation of all element ranges comes before all Table and Memory initialization.
591	forEachElement([&] (const Wasm::Element& element, uint32_t tableIndex, uint32_t elementIndex) {	588	forEachActiveElement([&] (const Wasm::Element& element, uint32_t tableIndex, uint32_t elementIndex) {
592	uint64_t lastWrittenIndex = static_cast<uint64_t>(elementIndex) + static_cast<uint64_t>(element.functionIndices.size()) - 1;	589	int64_t lastWrittenIndex = static_cast<int64_t>(elementIndex) + static_cast<int64_t>(element.functionIndices.size()) - 1;
593	if (UNLIKELY(lastWrittenIndex >= m_instance->table(tableIndex)->length()))	590	if (UNLIKELY(lastWrittenIndex >= m_instance->table(tableIndex)->length()))
594	exception = JSValue(throwException(globalObject, scope, createJSWebAssemblyLinkError(globalObject, vm, "Element is trying to set an out of bounds table index"_s)));	591	exception = JSValue(throwException(globalObject, scope, createJSWebAssemblyLinkError(globalObject, vm, "Element is trying to set an out of bounds table index"_s)));
595	});	592	});
Lines 608-615 JSValue WebAssemblyModuleRecord::evaluate(JSGlobalObject* globalObject) a/Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp_sec3
608	if (UNLIKELY(exception))	605	if (UNLIKELY(exception))
609	return exception.value();	606	return exception.value();
610		607
611	forEachElement([&] (const Wasm::Element& element, uint32_t tableIndex, uint32_t startElementIndex) {	608	forEachActiveElement([&] (const Wasm::Element& element, uint32_t tableIndex, uint32_t startElementIndex) {
612	for (uint32_t i = 0; i < element.functionIndices.size(); ++i) {	609	for (uint32_t i = 0; i < element.functionIndices.size(); ++i) {
		610
613	const uint32_t elementIndex = startElementIndex + i;	611	const uint32_t elementIndex = startElementIndex + i;
614	const uint32_t functionIndex = element.functionIndices[i];	612	const uint32_t functionIndex = element.functionIndices[i];
615	if (Wasm::Element::isNullFuncIndex(functionIndex)) {	613	if (Wasm::Element::isNullFuncIndex(functionIndex)) {

Lines 1-3 a/Tools/ChangeLog_sec1
- a/Tools/ChangeLog +11 lines
		1	2020-12-08 Dmitry Bezhetskov <dbezhetskov@igalia.com>
		2
		3	[WASM-References] Add table.init
		4	https://bugs.webkit.org/show_bug.cgi?id=219297
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Support ref-types spec tests.
		9
		10	* Scripts/run-jsc-stress-tests:
		11
1	2020-12-07 Fujii Hironori <Hironori.Fujii@sony.com>	12	2020-12-07 Fujii Hironori <Hironori.Fujii@sony.com>
2		13
3	Unreviewed sort-Xcode-project-file	14	Unreviewed sort-Xcode-project-file

Lines 1274-1279 def runWebAssemblySpecTest(mode) a/Tools/Scripts/run-jsc-stress-tests_sec1
- a/Tools/Scripts/run-jsc-stress-tests +26 lines
1274	end	1274	end
1275	end	1275	end
1276		1276
		1277	def runWebAssemblyReferenceSpecTest(mode)
		1278	case mode
		1279	when :skip
		1280	return
		1281	end
		1282	return if !$jitTests
		1283	return if !$isFTLPlatform
		1284	prepareExtraAbsoluteFiles(WASMTESTS_PATH, ["wasm.json"])
		1285
		1286	modules = Dir[WASMTESTS_PATH + "*.js"].map { \|f\| File.basename(f) }
		1287	prepareExtraRelativeFiles(modules.map { \|f\| "../../" + f }, $collection)
		1288
		1289	harness = Dir[WASMTESTS_PATH + "spec-harness/" + "*.js"].map { \|f\| File.basename(f) }
		1290	prepareExtraRelativeFiles(harness.map { \|f\| "../../spec-harness/" + f }, $collection)
		1291
		1292	runWithOutputHandler("default-wasm", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", *FTL_OPTIONS)
		1293	if $mode != "quick"
		1294	runWithOutputHandler("wasm-no-cjit-yes-tls-context", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--useFastTLSForWasmContext=true", *(FTL_OPTIONS + NO_CJIT_OPTIONS))
		1295	runWithOutputHandler("wasm-eager-jettison", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--forceCodeBlockToJettisonDueToOldAge=true", "--useRandomizingExecutableIslandAllocation=true", *FTL_OPTIONS)
		1296	runWithOutputHandler("wasm-no-tls-context", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--useFastTLSForWasmContext=false", *FTL_OPTIONS)
		1297	runWithOutputHandler("wasm-b3", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--useWasmLLInt=false", "--wasmBBQUsesAir=false", *FTL_OPTIONS)
		1298	runWithOutputHandler("wasm-air", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--useWasmLLInt=false", "--useRandomizingExecutableIslandAllocation=true", *FTL_OPTIONS)
		1299	runWithOutputHandler("wasm-collect-continuously", noisyOutputHandler, "../spec-harness.js", "--useWebAssemblyReferences=true", "--collectContinuously=true", *FTL_OPTIONS) if shouldCollectContinuously?
		1300	end
		1301	end
		1302
1277	def runWebAssemblyLowExecutableMemory(*optionalTestSpecificOptions)	1303	def runWebAssemblyLowExecutableMemory(*optionalTestSpecificOptions)
1278	return if !$jitTests	1304	return if !$jitTests
1279	return if !$isFTLPlatform	1305	return if !$isFTLPlatform

Lines 1-3 a/JSTests/ChangeLog_sec1
- a/JSTests/ChangeLog +25 lines
		1	2020-12-08 Dmitry Bezhetskov <dbezhetskov@igalia.com>
		2
		3	[WASM-References] Add table.init
		4	https://bugs.webkit.org/show_bug.cgi?id=219297
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Added reference types spec tests for element section, table.init
		9	and elem.drop:
		10	https://github.com/WebAssembly/reference-types/blob/master/test/core/elem.wast,
		11	https://github.com/WebAssembly/reference-types/blob/master/test/core/table_init.wast.
		12	Added tests for checking table instructions immediates when they are unreachable.
		13
		14	* wasm.yaml:
		15	* wasm/references-spec-tests/elem.wast.js: Added.
		16	* wasm/references-spec-tests/ref_is_null.js: Removed.
		17	* wasm/references-spec-tests/ref_is_null.wast.js: Added.
		18	* wasm/references-spec-tests/ref_null.js: Removed.
		19	* wasm/references-spec-tests/ref_null.wast.js: Added.
		20	* wasm/references-spec-tests/table_copy.wast.js: Renamed from JSTests/wasm/references-spec-tests/table_copy.js.
		21	* wasm/references-spec-tests/table_init.wast.js: Added.
		22	* wasm/spec-harness/wasm-constants.js:
		23	(hostref):
		24	* wasm/wasm.json:
		25
1	2020-12-07 Dmitry Bezhetskov <dbezhetskov@igalia.com>	26	2020-12-07 Dmitry Bezhetskov <dbezhetskov@igalia.com>
2		27
3	[WASM-References] Add support for table.copy	28	[WASM-References] Add support for table.copy

Lines 33-40 a/JSTests/wasm.yaml_sec1
- a/JSTests/wasm.yaml -2 / +11 lines
33	cmd: runWebAssemblySuite unless parseRunCommands	33	cmd: runWebAssemblySuite unless parseRunCommands
34	- path: wasm/references	34	- path: wasm/references
35	cmd: runWebAssemblySuite unless parseRunCommands	35	cmd: runWebAssemblySuite unless parseRunCommands
36	- path: wasm/references-spec-tests
37	cmd: runWebAssemblySuite unless parseRunCommands
38	- path: wasm/fuzz	36	- path: wasm/fuzz
39	cmd: runWebAssemblySuite unless parseRunCommands	37	cmd: runWebAssemblySuite unless parseRunCommands
40	- path: wasm/lowExecutableMemory	38	- path: wasm/lowExecutableMemory
Lines 46-51 a/JSTests/wasm.yaml_sec2
46	- path: wasm/self-test/	44	- path: wasm/self-test/
47	cmd: runWebAssemblySuite unless parseRunCommands	45	cmd: runWebAssemblySuite unless parseRunCommands
48		46
		47	- path: wasm/references-spec-tests/elem.wast.js
		48	cmd: runWebAssemblyReferenceSpecTest :normal
		49	- path: wasm/references-spec-tests/ref_null.wast.js
		50	cmd: runWebAssemblyReferenceSpecTest :normal
		51	- path: wasm/references-spec-tests/ref_is_null.wast.js
		52	cmd: runWebAssemblyReferenceSpecTest :normal
		53	- path: wasm/references-spec-tests/table_copy.wast.js
		54	cmd: runWebAssemblyReferenceSpecTest :normal
		55	- path: wasm/references-spec-tests/table_init.wast.js
		56	cmd: runWebAssemblyReferenceSpecTest :normal
		57
49	- path: wasm/multi-value-spec-tests/block.wast.js	58	- path: wasm/multi-value-spec-tests/block.wast.js
50	cmd: runWebAssemblySpecTest :normal	59	cmd: runWebAssemblySpecTest :normal
51	- path: wasm/multi-value-spec-tests/br.wast.js	60	- path: wasm/multi-value-spec-tests/br.wast.js

Line 0 a/JSTests/wasm/references-spec-tests/elem.wast.js_sec1
- a/JSTests/wasm/references-spec-tests/elem.wast.js +195 lines
		1
		2	// elem.wast:4
		3	let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x99\x83\x80\x80\x00\x3c\x01\x00\x00\x05\x70\x04\xd2\x00\x0b\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x01\x00\x00\x01\x00\x04\x00\x00\x01\x01\x01\x00\x00\x05\x70\x04\xd2\x00\x0b\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x01\x00\x00\x01\x00\x04\x00\x00\x01\x01\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x01\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x01\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x01\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x01\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x00\x04\x41\x00\x0b\x02\xd2\x00\x0b\xd0\x70\x0b\x00\x41\x00\x0b\x02\x00\x00\x00\x41\x00\x0b\x02\x00\x00\x03\x00\x00\x07\x70\x04\xd2\x00\x0b\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x03\x00\x00\x03\x00\x04\x00\x00\x01\x01\x03\x00\x00\x07\x70\x04\xd2\x00\x0b\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x03\x00\x00\x03\x00\x04\x00\x00\x01\x01\x0a\x8f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x82\x80\x80\x80\x00\x00\x0b");
		4
		5	// elem.wast:79
		6	let $2 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x85\x80\x80\x80\x00\x01\x70\x01\x03\x03\x09\x8f\x80\x80\x80\x00\x01\x04\x41\x00\x0b\x03\xd2\x00\x0b\xd0\x70\x0b\xd2\x01\x0b\x0a\x8f\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x82\x80\x80\x80\x00\x00\x0b");
		7
		8	// elem.wast:89
		9	let $3 = instance("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		10
		11	// elem.wast:94
		12	let $4 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		13
		14	// elem.wast:100
		15	let $5 = instance("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x9f\x80\x80\x80\x00\x05\x00\x41\x00\x0b\x01\x00\x00\x41\x03\x0b\x01\x00\x00\x41\x07\x0b\x01\x00\x00\x41\x05\x0b\x01\x00\x00\x41\x03\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		16
		17	// elem.wast:109
		18	let $6 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x9f\x80\x80\x80\x00\x05\x00\x41\x09\x0b\x01\x00\x00\x41\x03\x0b\x01\x00\x00\x41\x07\x0b\x01\x00\x00\x41\x03\x0b\x01\x00\x00\x41\x05\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		19
		20	// elem.wast:119
		21	let $7 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x98\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x0a\x67\x6c\x6f\x62\x61\x6c\x5f\x69\x33\x32\x03\x7f\x00\x03\x82\x80\x80\x80\x00\x01\x00\x04\x85\x80\x80\x80\x00\x01\x70\x00\xe8\x07\x09\x87\x80\x80\x80\x00\x01\x00\x23\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		22
		23	// elem.wast:126
		24	let $8 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x98\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x0a\x67\x6c\x6f\x62\x61\x6c\x5f\x69\x33\x32\x03\x7f\x00\x03\x82\x80\x80\x80\x00\x01\x00\x04\x85\x80\x80\x80\x00\x01\x70\x00\xe8\x07\x09\x87\x80\x80\x80\x00\x01\x00\x23\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		25
		26	// elem.wast:133
		27	let $9 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x85\x80\x80\x80\x00\x04\x00\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x93\x80\x80\x80\x00\x02\x06\x63\x61\x6c\x6c\x2d\x37\x00\x02\x06\x63\x61\x6c\x6c\x2d\x39\x00\x03\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x07\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\xad\x80\x80\x80\x00\x04\x85\x80\x80\x80\x00\x00\x41\xc1\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc2\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x07\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x09\x11\x00\x00\x0b");
		28
		29	// elem.wast:147
		30	assert_return(() => call($9, "call-7", []), 65);
		31
		32	// elem.wast:148
		33	assert_return(() => call($9, "call-9", []), 66);
		34
		35	// elem.wast:152
		36	let $10 = instance("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x09\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		37
		38	// elem.wast:157
		39	let $11 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x09\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		40
		41	// elem.wast:163
		42	let $12 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x00\x09\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");
		43
		44	// elem.wast:167
		45	let $13 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x00\x09\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");
		46
		47	// elem.wast:172
		48	let $14 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x85\x80\x80\x80\x00\x01\x70\x01\x00\x00\x09\x86\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x00");
		49
		50	// elem.wast:177
		51	let $15 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x14\x09\x86\x80\x80\x80\x00\x01\x00\x41\x14\x0b\x00");
		52
		53	// elem.wast:182
		54	let $16 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		55
		56	// elem.wast:188
		57	let $17 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x95\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x01\x00\x64\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		58
		59	// elem.wast:194
		60	let $18 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x00\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		61
		62	// elem.wast:200
		63	let $19 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x95\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x01\x00\x1e\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
		64
65	// elem.wast:208
66	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
67	// assert_uninstantiable("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
68
69	// elem.wast:217
70	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
71	// assert_uninstantiable("\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\x04\x85\x80\x80\x80\x00\x01\x70\x01\x00\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
72
73	// elem.wast:226
74	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
75	// assert_uninstantiable("\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\x04\x85\x80\x80\x80\x00\x01\x70\x01\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
76
77	// elem.wast:235
78	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
79	// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x00\x09\x86\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x00");
80
81	// elem.wast:242
82	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
83	// assert_uninstantiable("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x0a\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
84
85	// elem.wast:250
86	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
87	// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x0a\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
88
89	// elem.wast:259
90	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
91	// assert_uninstantiable("\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\x04\x85\x80\x80\x80\x00\x01\x70\x01\x0a\x14\x09\x87\x80\x80\x80\x00\x01\x00\x41\x0a\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
92
93	// elem.wast:267
94	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
95	// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x0a\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
96
97	// elem.wast:276
98	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
99	// assert_uninstantiable("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x7f\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
100
101	// elem.wast:284
102	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
103	// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x7f\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
104
105	// elem.wast:293
106	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
107	// assert_uninstantiable("\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\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x09\x87\x80\x80\x80\x00\x01\x00\x41\x76\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
108
109	// elem.wast:301
110	// FIXME: https://github.com/WebAssembly/bulk-memory-operations/issues/133.
111	// assert_uninstantiable("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x82\x80\x80\x80\x00\x01\x00\x09\x87\x80\x80\x80\x00\x01\x00\x41\x76\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
112
113	// elem.wast:312
114	let $20 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x69\x6e\x69\x74\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x01\xfc\x0c\x00\x00\x0b");
115
116	// elem.wast:320
117	assert_trap(() => call($20, "init", []));
118
119	// elem.wast:322
120	let $21 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x84\x80\x80\x80\x00\x01\x60\x00\x00\x03\x83\x80\x80\x80\x00\x02\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x88\x80\x80\x80\x00\x01\x04\x69\x6e\x69\x74\x00\x01\x09\x85\x80\x80\x80\x00\x01\x03\x00\x01\x00\x0a\x99\x80\x80\x80\x00\x02\x82\x80\x80\x80\x00\x00\x0b\x8c\x80\x80\x80\x00\x00\x41\x00\x41\x00\x41\x01\xfc\x0c\x00\x00\x0b");
121
122	// elem.wast:330
123	assert_trap(() => call($21, "init", []));
124
125	// elem.wast:334
126	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\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x0b\x01\x00\x0a\x88\x80\x80\x80\x00\x01\x82\x80\x80\x80\x00\x00\x0b");
127
128	// elem.wast:344
129	assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x86\x80\x80\x80\x00\x01\x00\x42\x00\x0b\x00");
130
131	// elem.wast:352
132	assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x68\x0b\x00");
133
134	// elem.wast:360
135	assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x85\x80\x80\x80\x00\x01\x00\x01\x0b\x00");
136
137	// elem.wast:368
138	assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x01\x41\x00\x0b\x00");
139
140	// elem.wast:376
141	assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x01\x09\x87\x80\x80\x80\x00\x01\x00\x41\x00\x01\x0b\x00");
142
143	// elem.wast:392
144	let $22 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x84\x80\x80\x80\x00\x03\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\x94\x80\x80\x80\x00\x01\x10\x63\x61\x6c\x6c\x2d\x6f\x76\x65\x72\x77\x72\x69\x74\x74\x65\x6e\x00\x02\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x09\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\xa1\x80\x80\x80\x00\x03\x85\x80\x80\x80\x00\x00\x41\xc1\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc2\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x09\x11\x00\x00\x0b");
145
146	// elem.wast:403
147	assert_return(() => call($22, "call-overwritten", []), 66);
148
149	// elem.wast:405
150	let $23 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x02\x94\x80\x80\x80\x00\x01\x08\x73\x70\x65\x63\x74\x65\x73\x74\x05\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x84\x80\x80\x80\x00\x03\x00\x00\x00\x07\x9c\x80\x80\x80\x00\x01\x18\x63\x61\x6c\x6c\x2d\x6f\x76\x65\x72\x77\x72\x69\x74\x74\x65\x6e\x2d\x65\x6c\x65\x6d\x65\x6e\x74\x00\x02\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x09\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\xa1\x80\x80\x80\x00\x03\x85\x80\x80\x80\x00\x00\x41\xc1\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc2\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x09\x11\x00\x00\x0b");
151
152	// elem.wast:416
153	assert_return(() => call($23, "call-overwritten-element", []), 66);
154
155	// elem.wast:420
156	let $24 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x03\x86\x80\x80\x80\x00\x05\x00\x00\x00\x00\x00\x04\x84\x80\x80\x80\x00\x01\x70\x00\x0a\x07\xab\x80\x80\x80\x00\x04\x0c\x73\x68\x61\x72\x65\x64\x2d\x74\x61\x62\x6c\x65\x01\x00\x06\x63\x61\x6c\x6c\x2d\x37\x00\x02\x06\x63\x61\x6c\x6c\x2d\x38\x00\x03\x06\x63\x61\x6c\x6c\x2d\x39\x00\x04\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x08\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\xb9\x80\x80\x80\x00\x05\x85\x80\x80\x80\x00\x00\x41\xc1\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc2\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x07\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x08\x11\x00\x00\x0b\x87\x80\x80\x80\x00\x00\x41\x09\x11\x00\x00\x0b");
157	let $module1 = $24;
158
159	// elem.wast:438
160	register("module1", $module1)
161
162	// elem.wast:440
163	assert_trap(() => call($module1, "call-7", []));
164
165	// elem.wast:441
166	assert_return(() => call($module1, "call-8", []), 65);
167
168	// elem.wast:442
169	assert_return(() => call($module1, "call-9", []), 66);
170
171	// elem.wast:444
172	let $25 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x02\x9a\x80\x80\x80\x00\x01\x07\x6d\x6f\x64\x75\x6c\x65\x31\x0c\x73\x68\x61\x72\x65\x64\x2d\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x83\x80\x80\x80\x00\x02\x00\x00\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x07\x0b\x01\x00\x00\x41\x08\x0b\x01\x01\x0a\x95\x80\x80\x80\x00\x02\x85\x80\x80\x80\x00\x00\x41\xc3\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc4\x00\x0b");
173	let $module2 = $25;
174
175	// elem.wast:453
176	assert_return(() => call($module1, "call-7", []), 67);
177
178	// elem.wast:454
179	assert_return(() => call($module1, "call-8", []), 68);
180
181	// elem.wast:455
182	assert_return(() => call($module1, "call-9", []), 66);
183
184	// elem.wast:457
185	let $26 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x00\x01\x7f\x02\x9a\x80\x80\x80\x00\x01\x07\x6d\x6f\x64\x75\x6c\x65\x31\x0c\x73\x68\x61\x72\x65\x64\x2d\x74\x61\x62\x6c\x65\x01\x70\x00\x0a\x03\x83\x80\x80\x80\x00\x02\x00\x00\x09\x8d\x80\x80\x80\x00\x02\x00\x41\x08\x0b\x01\x00\x00\x41\x09\x0b\x01\x01\x0a\x95\x80\x80\x80\x00\x02\x85\x80\x80\x80\x00\x00\x41\xc5\x00\x0b\x85\x80\x80\x80\x00\x00\x41\xc6\x00\x0b");
186	let $module3 = $26;
187
188	// elem.wast:466
189	assert_return(() => call($module1, "call-7", []), 67);
190
191	// elem.wast:467
192	assert_return(() => call($module1, "call-8", []), 69);
193
194	// elem.wast:468
195	assert_return(() => call($module1, "call-9", []), 70);

Lines 1-220 a/JSTests/wasm/references-spec-tests/ref_is_null.js_sec1
- a/JSTests/wasm/references-spec-tests/ref_is_null.js -220 lines
1	//@ runWebAssemblySuite("--useWebAssemblyReferences=true")
2	'use strict';
3	let console = { log: print }
4	let hostrefs = {};
5	let hostsym = Symbol("hostref");
6	function hostref(s) {
7	if (! (s in hostrefs)) hostrefs[s] = {[hostsym]: s};
8	return hostrefs[s];
9	}
10	function is_hostref(x) {
11	return (x !== null && hostsym in x) ? 1 : 0;
12	}
13	function is_funcref(x) {
14	return typeof x === "function" ? 1 : 0;
15	}
16	function eq_ref(x, y) {
17	return x === y ? 1 : 0;
18	}
19
20	let spectest = {
21	hostref: hostref,
22	is_hostref: is_hostref,
23	is_funcref: is_funcref,
24	eq_ref: eq_ref,
25	print: console.log.bind(console),
26	print_i32: console.log.bind(console),
27	print_i32_f32: console.log.bind(console),
28	print_f64_f64: console.log.bind(console),
29	print_f32: console.log.bind(console),
30	print_f64: console.log.bind(console),
31	global_i32: 666,
32	global_f32: 666,
33	global_f64: 666,
34	table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),
35	memory: new WebAssembly.Memory({initial: 1, maximum: 2})
36	};
37
38	let handler = {
39	get(target, prop) {
40	return (prop in target) ? target[prop] : {};
41	}
42	};
43	let registry = new Proxy({spectest}, handler);
44
45	function register(name, instance) {
46	registry[name] = instance.exports;
47	}
48
49	function module(bytes, valid = true) {
50	let buffer = new ArrayBuffer(bytes.length);
51	let view = new Uint8Array(buffer);
52	for (let i = 0; i < bytes.length; ++i) {
53	view[i] = bytes.charCodeAt(i);
54	}
55	let validated;
56	try {
57	validated = WebAssembly.validate(buffer);
58	} catch (e) {
59	throw new Error("Wasm validate throws");
60	}
61	if (validated !== valid) {
62	throw new Error("Wasm validate failure" + (valid ? "" : " expected"));
63	}
64	return new WebAssembly.Module(buffer);
65	}
66
67	function instance(bytes, imports = registry) {
68	return new WebAssembly.Instance(module(bytes), imports);
69	}
70
71	function call(instance, name, args) {
72	return instance.exports[name](...args);
73	}
74
75	function get(instance, name) {
76	let v = instance.exports[name];
77	return (v instanceof WebAssembly.Global) ? v.value : v;
78	}
79
80	function exports(instance) {
81	return {module: instance.exports, spectest: spectest};
82	}
83
84	function run(action) {
85	action();
86	}
87
88	function assert_malformed(bytes) {
89	try { module(bytes, false) } catch (e) {
90	if (e instanceof WebAssembly.CompileError) return;
91	}
92	throw new Error("Wasm decoding failure expected");
93	}
94
95	function assert_invalid(bytes) {
96	try { module(bytes, false) } catch (e) {
97	if (e instanceof WebAssembly.CompileError) return;
98	}
99	throw new Error("Wasm validation failure expected");
100	}
101
102	function assert_unlinkable(bytes) {
103	let mod = module(bytes);
104	try { new WebAssembly.Instance(mod, registry) } catch (e) {
105	if (e instanceof WebAssembly.LinkError) return;
106	}
107	throw new Error("Wasm linking failure expected");
108	}
109
110	function assert_uninstantiable(bytes) {
111	let mod = module(bytes);
112	try { new WebAssembly.Instance(mod, registry) } catch (e) {
113	if (e instanceof WebAssembly.RuntimeError) return;
114	}
115	throw new Error("Wasm trap expected");
116	}
117
118	function assert_trap(action) {
119	try { action() } catch (e) {
120	if (e instanceof WebAssembly.RuntimeError) return;
121	}
122	throw new Error("Wasm trap expected");
123	}
124
125	let StackOverflow;
126	try { (function f() { 1 + f() })() } catch (e) { StackOverflow = e.constructor }
127
128	function assert_exhaustion(action) {
129	try { action() } catch (e) {
130	if (e instanceof StackOverflow) return;
131	}
132	throw new Error("Wasm resource exhaustion expected");
133	}
134
135	function assert_return(action, expected) {
136	let actual = action();
137	if (!Object.is(actual, expected)) {
138	throw new Error("Wasm return value " + expected + " expected, got " + actual);
139	};
140	}
141
142	function assert_return_canonical_nan(action) {
143	let actual = action();
144	// Note that JS can't reliably distinguish different NaN values,
145	// so there's no good way to test that it's a canonical NaN.
146	if (!Number.isNaN(actual)) {
147	throw new Error("Wasm return value NaN expected, got " + actual);
148	};
149	}
150
151	function assert_return_arithmetic_nan(action) {
152	// Note that JS can't reliably distinguish different NaN values,
153	// so there's no good way to test for specific bitpatterns here.
154	let actual = action();
155	if (!Number.isNaN(actual)) {
156	throw new Error("Wasm return value NaN expected, got " + actual);
157	};
158	}
159
160	function assert_return_ref(action) {
161	let actual = action();
162	if (actual === null \|\| typeof actual !== "object" && typeof actual !== "function") {
163	throw new Error("Wasm reference return value expected, got " + actual);
164	};
165	}
166
167	function assert_return_func(action) {
168	let actual = action();
169	if (typeof actual !== "function") {
170	throw new Error("Wasm function return value expected, got " + actual);
171	};
172	}
173
174	// ref_is_null.wast:1
175	let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x97\x80\x80\x80\x00\x05\x60\x01\x70\x01\x7f\x60\x01\x6f\x01\x7f\x60\x00\x00\x60\x01\x6f\x00\x60\x01\x7f\x01\x7f\x03\x88\x80\x80\x80\x00\x07\x00\x01\x02\x03\x02\x04\x04\x04\x87\x80\x80\x80\x00\x02\x70\x00\x02\x6f\x00\x02\x07\xc7\x80\x80\x80\x00\x06\x07\x66\x75\x6e\x63\x72\x65\x66\x00\x00\x09\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x00\x01\x04\x69\x6e\x69\x74\x00\x03\x06\x64\x65\x69\x6e\x69\x74\x00\x04\x0c\x66\x75\x6e\x63\x72\x65\x66\x2d\x65\x6c\x65\x6d\x00\x05\x0e\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x2d\x65\x6c\x65\x6d\x00\x06\x09\x87\x80\x80\x80\x00\x01\x00\x41\x01\x0b\x01\x02\x0a\xd6\x80\x80\x80\x00\x07\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b\x82\x80\x80\x80\x00\x00\x0b\x88\x80\x80\x80\x00\x00\x41\x01\x20\x00\x26\x01\x0b\x8e\x80\x80\x80\x00\x00\x41\x01\xd0\x70\x26\x00\x41\x01\xd0\x6f\x26\x01\x0b\x88\x80\x80\x80\x00\x00\x20\x00\x25\x00\x10\x00\x0b\x88\x80\x80\x80\x00\x00\x20\x00\x25\x01\x10\x01\x0b");
176
177	// ref_is_null.wast:30
178	assert_return(() => call($1, "funcref", [null]), 1);
179
180	// ref_is_null.wast:31
181	assert_return(() => call($1, "externref", [null]), 1);
182
183	// ref_is_null.wast:33
184	assert_return(() => call($1, "externref", [hostref(1)]), 0);
185
186	// ref_is_null.wast:35
187	run(() => call($1, "init", [hostref(0)]));
188
189	// ref_is_null.wast:37
190	assert_return(() => call($1, "funcref-elem", [0]), 1);
191
192	// ref_is_null.wast:38
193	assert_return(() => call($1, "externref-elem", [0]), 1);
194
195	// ref_is_null.wast:40
196	assert_return(() => call($1, "funcref-elem", [1]), 0);
197
198	// ref_is_null.wast:41
199	assert_return(() => call($1, "externref-elem", [1]), 0);
200
201	// ref_is_null.wast:43
202	run(() => call($1, "deinit", []));
203
204	// ref_is_null.wast:45
205	assert_return(() => call($1, "funcref-elem", [0]), 1);
206
207	// ref_is_null.wast:46
208	assert_return(() => call($1, "externref-elem", [0]), 1);
209
210	// ref_is_null.wast:48
211	assert_return(() => call($1, "funcref-elem", [1]), 1);
212
213	// ref_is_null.wast:49
214	assert_return(() => call($1, "externref-elem", [1]), 1);
215
216	// ref_is_null.wast:51
217	assert_invalid("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x85\x80\x80\x80\x00\x01\x60\x01\x7f\x00\x03\x82\x80\x80\x80\x00\x01\x00\x0a\x8b\x80\x80\x80\x00\x01\x85\x80\x80\x80\x00\x00\x20\x00\xd1\x0b");
218
219	// ref_is_null.wast:55
220	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\x89\x80\x80\x80\x00\x01\x83\x80\x80\x80\x00\x00\xd1\x0b");

Line 0 a/JSTests/wasm/references-spec-tests/ref_null.wast.js_sec1
- a/JSTests/wasm/references-spec-tests/ref_null.wast.js +9 lines
	1
	2	// ref_null.wast:1
	3	let $1 = instance("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x89\x80\x80\x80\x00\x02\x60\x00\x01\x6f\x60\x00\x01\x70\x03\x83\x80\x80\x80\x00\x02\x00\x01\x06\x8b\x80\x80\x80\x00\x02\x6f\x00\xd0\x6f\x0b\x70\x00\xd0\x70\x0b\x07\x97\x80\x80\x80\x00\x02\x09\x65\x78\x74\x65\x72\x6e\x72\x65\x66\x00\x00\x07\x66\x75\x6e\x63\x72\x65\x66\x00\x01\x0a\x93\x80\x80\x80\x00\x02\x84\x80\x80\x80\x00\x00\xd0\x6f\x0b\x84\x80\x80\x80\x00\x00\xd0\x70\x0b");
	4
	5	// ref_null.wast:9
	6	assert_return(() => call($1, "externref", []), null);
	7
	8	// ref_null.wast:10
	9	assert_return(() => call($1, "funcref", []), null);

Line 0 a/JSTests/wasm/references/table_instructions_parse_unreachable.js_sec1
- a/JSTests/wasm/references/table_instructions_parse_unreachable.js +241 lines
		1	//@ runWebAssemblySuite("--useWebAssemblyReferences=true")
		2	import * as assert from '../assert.js';
		3
		4	function module(bytes, valid = true) {
		5	let buffer = new ArrayBuffer(bytes.length);
		6	let view = new Uint8Array(buffer);
		7	for (let i = 0; i < bytes.length; ++i) {
		8	view[i] = bytes.charCodeAt(i);
		9	}
		10	return new WebAssembly.Module(buffer);
		11	}
		12
		13	async function validTableInitUnreachable() {
		14	/*
		15	(module
		16	(type $type1 (func (result i32)))
		17	(table $t 10 funcref)
		18	(func $f (result i32) i32.const 37)
		19	(elem $elem0 funcref (ref.null func) (ref.func $f) (ref.func $f))
		20	(func (export "run")
		21	(return)
		22	(table.init $t $elem0 (i32.const 1) (i32.const 2) (i32.const 3))
		23	)
		24	)
		25	*/
		26	let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x03\x02\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x01\x09\x0d\x01\x05\x70\x03\xd0\x70\x0b\xd2\x00\x0b\xd2\x00\x0b\x0a\x14\x02\x04\x00\x41\x25\x0b\x0d\x00\x0f\x41\x01\x41\x02\x41\x03\xfc\x0c\x00\x00\x0b"));
		27	instance.exports.run();
		28	}
		29
		30	function invalidTableInitUnreachable() {
		31	/*
		32	(module
		33	(type $type1 (func (result i32)))
		34	(table $t 10 funcref)
		35	(func $f (result i32) i32.const 37)
		36	(elem $elem0 funcref (ref.null func) (ref.func $f) (ref.func $f))
		37	(func (export "run")
		38	(return)
		39	(table.init $t 11 (i32.const 1) (i32.const 2) (i32.const 3))
		40	)
		41	)
		42	*/
		43	assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x03\x02\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x01\x09\x0d\x01\x05\x70\x03\xd0\x70\x0b\xd2\x00\x0b\xd2\x00\x0b\x0a\x14\x02\x04\x00\x41\x25\x0b\x0d\x00\x0f\x41\x01\x41\x02\x41\x0b\xfc\x0c\x0b\x00\x0b"),
		44	WebAssembly.CompileError,
		45	"WebAssembly.Module doesn't validate: element index 11 is invalid, limit is 1, in function at index 1 (evaluating 'new WebAssembly.Module(buffer)')");
		46
		47	/*
		48	(module
		49	(type $type1 (func (result i32)))
		50	(table $t 10 funcref)
		51	(func $f (result i32) i32.const 37)
		52	(elem $elem0 funcref (ref.null func) (ref.func $f) (ref.func $f))
		53	(func (export "run")
		54	(return)
		55	(table.init 11 $elem0 (i32.const 1) (i32.const 2) (i32.const 3))
		56	)
		57	)
		58	*/
		59	assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x03\x02\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x01\x09\x0d\x01\x05\x70\x03\xd0\x70\x0b\xd2\x00\x0b\xd2\x00\x0b\x0a\x14\x02\x04\x00\x41\x25\x0b\x0d\x00\x0f\x41\x01\x41\x02\x41\x0b\xfc\x0c\x00\x0b\x0b"),
		60	WebAssembly.CompileError,
		61	"WebAssembly.Module doesn't validate: table index 11 is invalid, limit is 1, in function at index 1 (evaluating 'new WebAssembly.Module(buffer)')");
		62	}
		63
		64	function validTableSizeUnreachable() {
65	/*
66	(module
67	(table $t 10 funcref)
68	(func (export "run")
69	(return)
70	(drop (table.size $t))
71	)
72	)
73	*/
74	let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x09\x01\x07\x00\x0f\xfc\x10\x00\x1a\x0b"));
75	instance.exports.run();
76	}
77
78	function invalidTableSizeUnreachable() {
79	/*
80	(module
81	(table $t 10 funcref)
82	(func (export "run")
83	(return)
84	(drop (table.size 10))
85	)
86	)
87	*/
88	assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x09\x01\x07\x00\x0f\xfc\x10\x0a\x1a\x0b"),
89	WebAssembly.CompileError,
90	"WebAssembly.Module doesn't validate: table index 10 is invalid, limit is 1, in function at index 0 (evaluating 'new WebAssembly.Module(buffer)')");
91	}
92
93	function validElemDropUnreachable() {
94	/*
95	(module
96	(func $f (result i32) (i32.const 37))
97	(func $g (result i32) (i32.const 42))
98	(table $t0 10 funcref)
99	(elem $e0 func $f $f $g $g)
100
101	(func (export "run")
102	(return)
103	(elem.drop $e0)
104	)
105	)
106	*/
107	let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x04\x03\x00\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x02\x09\x08\x01\x01\x00\x04\x00\x00\x01\x01\x0a\x12\x03\x04\x00\x41\x25\x0b\x04\x00\x41\x2a\x0b\x06\x00\x0f\xfc\x0d\x00\x0b"));
108	instance.exports.run();
109	}
110
111	function invalidElemDropUnreachable() {
112	/*
113	(module
114	(func $f (result i32) (i32.const 37))
115	(func $g (result i32) (i32.const 42))
116	(table $t0 10 funcref)
117	(elem $e0 func $f $f $g $g)
118
119	(func (export "run")
120	(return)
121	(elem.drop 10)
122	)
123	)
124	*/
125	assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x04\x03\x00\x00\x01\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x02\x09\x08\x01\x01\x00\x04\x00\x00\x01\x01\x0a\x12\x03\x04\x00\x41\x25\x0b\x04\x00\x41\x2a\x0b\x06\x00\x0f\xfc\x0d\x0a\x0b"),
126	WebAssembly.CompileError,
127	"WebAssembly.Module doesn't validate: element index 10 is invalid, limit is 1, in function at index 2 (evaluating 'new WebAssembly.Module(buffer)')");
128	}
129
130	function validTableGrowUnreachable() {
131	/*
132	(module
133	(table $t0 10 funcref)
134	(func (export "run")
135	(return)
136	(drop (table.grow $t0 (i32.const 37)))
137	)
138	)
139	*/
140	let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x0b\x01\x09\x00\x0f\x41\x25\xfc\x0f\x00\x1a\x0b"));
141	instance.exports.run();
142	}
143
144	function invalidTableGrowUnreachable() {
145	/*
146	(module
147	(table $t0 10 funcref)
148	(func (export "run")
149	(return)
150	(drop (table.grow 10 (i32.const 37)))
151	)
152	)
153	*/
154	assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x0b\x01\x09\x00\x0f\x41\x25\xfc\x0f\x0a\x1a\x0b"),
155	WebAssembly.CompileError,
156	"WebAssembly.Module doesn't validate: table index 10 is invalid, limit is 1, in function at index 0 (evaluating 'new WebAssembly.Module(buffer)')");
157	}
158
159	function validTableFillUnreachable() {
160	/*
161	(module
162	(table $t0 10 funcref)
163	(func (export "run")
164	(return)
165	(table.fill $t0 (i32.const 0) (ref.null func) (i32.const 7))
166	)
167	)
168	*/
169	let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x0e\x01\x0c\x00\x0f\x41\x00\xd0\x70\x41\x07\xfc\x11\x00\x0b"));
170	instance.exports.run();
171	}
172
173	function invalidTableFillUnreachable() {
174	/*
175	(module
176	(table $t0 10 funcref)
177	(func (export "run")
178	(return)
179	(drop (table.grow 10 (i32.const 37)))
180	)
181	)
182	*/
183	assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x04\x01\x60\x00\x00\x03\x02\x01\x00\x04\x04\x01\x70\x00\x0a\x07\x07\x01\x03\x72\x75\x6e\x00\x00\x0a\x0e\x01\x0c\x00\x0f\x41\x00\xd0\x70\x41\x07\xfc\x11\x0a\x0b"),
184	WebAssembly.CompileError,
185	"WebAssembly.Module doesn't validate: table index 10 is invalid, limit is 1, in function at index 0 (evaluating 'new WebAssembly.Module(buffer)')");
186	}
187
188	function validTableCopyUnreachable() {
189	/*
190	(module
191	(func $f (result i32) (i32.const 37))
192	(func $g (result i32) (i32.const 42))
193	(table $t0 10 funcref)
194	(elem (table $t0) (i32.const 0) func $f $f $g $g $f)
195	(table $t1 20 funcref)
196	(func (export "run")
197	(return)
198	(table.copy $t1 $t0 (i32.const 1) (i32.const 0) (i32.const 5))
199	)
200	)
201	*/
202	let instance = new WebAssembly.Instance(module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x04\x03\x00\x00\x01\x04\x07\x02\x70\x00\x0a\x70\x00\x14\x07\x07\x01\x03\x72\x75\x6e\x00\x02\x09\x0b\x01\x00\x41\x00\x0b\x05\x00\x00\x01\x01\x00\x0a\x19\x03\x04\x00\x41\x25\x0b\x04\x00\x41\x2a\x0b\x0d\x00\x0f\x41\x01\x41\x00\x41\x05\xfc\x0e\x01\x00\x0b"));
203	instance.exports.run();
204	}
205
206	function invalidTableCopyUnreachable() {
207	/*
208	(module
209	(func $f (result i32) (i32.const 37))
210	(func $g (result i32) (i32.const 42))
211	(table $t0 10 funcref)
212	(elem (table $t0) (i32.const 0) func $f $f $g $g $f)
213	(table $t1 20 funcref)
214	(func (export "run")
215	(return)
216	(table.copy 10 $t0 (i32.const 1) (i32.const 0) (i32.const 5))
217	)
218	)
219	*/
220	assert.throws(() => module("\x00\x61\x73\x6d\x01\x00\x00\x00\x01\x08\x02\x60\x00\x01\x7f\x60\x00\x00\x03\x04\x03\x00\x00\x01\x04\x07\x02\x70\x00\x0a\x70\x00\x14\x07\x07\x01\x03\x72\x75\x6e\x00\x02\x09\x0b\x01\x00\x41\x00\x0b\x05\x00\x00\x01\x01\x00\x0a\x19\x03\x04\x00\x41\x25\x0b\x04\x00\x41\x2a\x0b\x0d\x00\x0f\x41\x01\x41\x00\x41\x05\xfc\x0e\x0a\x00\x0b"),
221	WebAssembly.CompileError,
222	"WebAssembly.Module doesn't validate: table index 10 is invalid, limit is 2, in function at index 2 (evaluating 'new WebAssembly.Module(buffer)')");
223	}
224
225	validTableInitUnreachable();
226	invalidTableInitUnreachable();
227
228	validTableSizeUnreachable();
229	invalidTableSizeUnreachable();
230
231	validElemDropUnreachable();
232	invalidElemDropUnreachable();
233
234	validTableGrowUnreachable();
235	invalidTableGrowUnreachable();
236
237	validTableFillUnreachable();
238	invalidTableFillUnreachable();
239
240	validTableCopyUnreachable();
241	invalidTableCopyUnreachable();