#include "w2c2\w2c2\array.h"
#include "w2c2\w2c2\buffer.h"
#include "w2c2\w2c2\c.h"
#include "w2c2\w2c2\compat.h"
#include "w2c2\w2c2\datasegment.h"
#include "w2c2\w2c2\debug.h"
#include "w2c2\w2c2\elementsegment.h"
#include "w2c2\w2c2\export.h"
#include "w2c2\w2c2\file.h"
#include "w2c2\w2c2\function.h"
#include "w2c2\w2c2\functiontype.h"
#include "w2c2\w2c2\getopt_impl.h"
#include "w2c2\w2c2\global.h"
#include "w2c2\w2c2\import.h"
#include "w2c2\w2c2\instruction.h"
#include "w2c2\w2c2\labelstack.h"
#include "w2c2\w2c2\leb128.h"
#include "w2c2\w2c2\locals.h"
#include "w2c2\w2c2\memory.h"
#include "w2c2\w2c2\module.h"
#include "w2c2\w2c2\name.h"
#include "w2c2\w2c2\opcode.h"
#include "w2c2\w2c2\path.h"
#include "w2c2\w2c2\reader.h"
#include "w2c2\w2c2\section.h"
#include "w2c2\w2c2\sha1.h"
#include "w2c2\w2c2\str.h"
#include "w2c2\w2c2\stringbuilder.h"
#include "w2c2\w2c2\table.h"
#include "w2c2\w2c2\typestack.h"
#include "w2c2\w2c2\valuetype.h"
#include "w2c2\w2c2\w2c2_base.h"
wasmMemory * wasmMemoryAllocate__extern(const U32 initialPages, const U32 maxPages, const bool shared) { return wasmMemoryAllocate(initialPages, maxPages, shared); }
void wasmMemoryFree__extern(wasmMemory *memory) { wasmMemoryFree(memory); }
U32 wasmMemoryGrow__extern(wasmMemory *memory, const U32 delta) { return wasmMemoryGrow(memory, delta); }
void wasmMemoryCopy__extern(const wasmMemory *destinationMemory, const wasmMemory *sourceMemory, const U32 destinationAddress, const U32 sourceAddress, const U32 count) { wasmMemoryCopy(destinationMemory, sourceMemory, destinationAddress, sourceAddress, count); }
void wasmMemoryFill__extern(const wasmMemory *memory, const U32 destinationAddress, const U32 value, const U32 count) { wasmMemoryFill(memory, destinationAddress, value, count); }
void wasmTableAllocate__extern(wasmTable *table, const U32 size, const U32 maxSize) { wasmTableAllocate(table, size, maxSize); }
void wasmTableFree__extern(wasmTable *table) { wasmTableFree(table); }
bool arrayEnsureCapacity__extern(void **items, const size_t length, size_t *capacity, const size_t itemSize) { return arrayEnsureCapacity(items, length, capacity, itemSize); }
void bufferSkipUnchecked__extern(Buffer *buffer, const size_t length) { bufferSkipUnchecked(buffer, length); }
bool bufferReadEqual__extern(Buffer *buffer, const U8 *data, const size_t length) { return bufferReadEqual(buffer, data, length); }
bool bufferReadByte__extern(Buffer *buffer, U8 *result) { return bufferReadByte(buffer, result); }
bool bufferReadF32__extern(Buffer *buffer, I32 *result) { return bufferReadF32(buffer, result); }
bool bufferReadF64__extern(Buffer *buffer, I64 *result) { return bufferReadF64(buffer, result); }
bool bufferAtEnd__extern(const Buffer *buffer) { return bufferAtEnd(buffer); }
void bufferSkip__extern(Buffer *buffer, size_t length) { bufferSkip(buffer, length); }
bool wasmDecodeValueType__extern(const I32 encodedValueType, WasmValueType *result) { return wasmDecodeValueType(encodedValueType, result); }
bool wasmReadValueType__extern(Buffer *buffer, WasmValueType *result) { return wasmReadValueType(buffer, result); }
bool wasmReadBlockType__extern(Buffer *buffer, WasmValueType **result) { return wasmReadBlockType(buffer, result); }
bool wasmLocalsDeclarationsGetType__extern(const WasmLocalsDeclarations localsDeclarations, const U32 localIndex, WasmValueType *result) { return wasmLocalsDeclarationsGetType(localsDeclarations, localIndex, result); }
bool wasmFunctionIDsEnsureCapacity__extern(WasmFunctionIDs *wasmFunctionIDs, size_t length) { return wasmFunctionIDsEnsureCapacity(wasmFunctionIDs, length); }
bool wasmFunctionIDsAppend__extern(WasmFunctionIDs *wasmFunctionIDs, WasmFunctionID functionID) { return wasmFunctionIDsAppend(wasmFunctionIDs, functionID); }
void wasmFunctionIDsFree__extern(WasmFunctionIDs *wasmFunctionIDs) { wasmFunctionIDsFree(wasmFunctionIDs); }
bool wasmFunctionImportsEnsureCapacity__extern(WasmFunctionImports *wasmFunctionImports, size_t length) { return wasmFunctionImportsEnsureCapacity(wasmFunctionImports, length); }
bool wasmFunctionImportsAppend__extern(WasmFunctionImports *wasmFunctionImports, WasmFunctionImport import) { return wasmFunctionImportsAppend(wasmFunctionImports, import); }
void wasmFunctionImportsFree__extern(WasmFunctionImports *wasmFunctionImports) { wasmFunctionImportsFree(wasmFunctionImports); }
bool wasmGlobalImportsEnsureCapacity__extern(WasmGlobalImports *wasmGlobalImports, size_t length) { return wasmGlobalImportsEnsureCapacity(wasmGlobalImports, length); }
bool wasmGlobalImportsAppend__extern(WasmGlobalImports *wasmGlobalImports, WasmGlobalImport import) { return wasmGlobalImportsAppend(wasmGlobalImports, import); }
void wasmGlobalImportsFree__extern(WasmGlobalImports *wasmGlobalImports) { wasmGlobalImportsFree(wasmGlobalImports); }
bool wasmMemoryImportsEnsureCapacity__extern(WasmMemoryImports *wasmMemoryImports, size_t length) { return wasmMemoryImportsEnsureCapacity(wasmMemoryImports, length); }
bool wasmMemoryImportsAppend__extern(WasmMemoryImports *wasmMemoryImports, WasmMemoryImport import) { return wasmMemoryImportsAppend(wasmMemoryImports, import); }
void wasmMemoryImportsFree__extern(WasmMemoryImports *wasmMemoryImports) { wasmMemoryImportsFree(wasmMemoryImports); }
bool wasmTableImportsEnsureCapacity__extern(WasmTableImports *wasmTableImports, size_t length) { return wasmTableImportsEnsureCapacity(wasmTableImports, length); }
bool wasmTableImportsAppend__extern(WasmTableImports *wasmTableImports, WasmTableImport import) { return wasmTableImportsAppend(wasmTableImports, import); }
void wasmTableImportsFree__extern(WasmTableImports *wasmTableImports) { wasmTableImportsFree(wasmTableImports); }
bool wasmDebugSectionsEnsureCapacity__extern(WasmDebugSections *wasmDebugSections, size_t length) { return wasmDebugSectionsEnsureCapacity(wasmDebugSections, length); }
bool wasmDebugSectionsAppend__extern(WasmDebugSections *wasmDebugSections, WasmDebugSection debugSection) { return wasmDebugSectionsAppend(wasmDebugSections, debugSection); }
void wasmDebugSectionsFree__extern(WasmDebugSections *wasmDebugSections) { wasmDebugSectionsFree(wasmDebugSections); }
bool wasmDebugLinesEnsureCapacity__extern(WasmDebugLines *wasmDebugLines, size_t length) { return wasmDebugLinesEnsureCapacity(wasmDebugLines, length); }
bool wasmDebugLinesAppend__extern(WasmDebugLines *wasmDebugLines, WasmDebugLine debugLine) { return wasmDebugLinesAppend(wasmDebugLines, debugLine); }
void wasmDebugLinesFree__extern(WasmDebugLines *wasmDebugLines) { wasmDebugLinesFree(wasmDebugLines); }
bool wasmNamesEnsureCapacity__extern(WasmNames *wasmNames, size_t length) { return wasmNamesEnsureCapacity(wasmNames, length); }
bool wasmNamesAppend__extern(WasmNames *wasmNames, char *name) { return wasmNamesAppend(wasmNames, name); }
void wasmNamesFree__extern(WasmNames *wasmNames) { wasmNamesFree(wasmNames); }
bool wasmModuleFunctionGetLocalType__extern(const WasmModule *module, const WasmFunction function, const U32 localIndex, WasmValueType *result) { return wasmModuleFunctionGetLocalType(module, function, localIndex, result); }
bool wasmModuleGetGlobalType__extern(const WasmModule *module, U32 globalIndex, WasmValueType *result) { return wasmModuleGetGlobalType(module, globalIndex, result); }
bool wasmModuleGetFunctionType__extern(const WasmModule *module, U32 functionIndex, WasmFunctionType *result) { return wasmModuleGetFunctionType(module, functionIndex, result); }
bool wasmOpcodeRead__extern(Buffer *buffer, WasmOpcode *result) { return wasmOpcodeRead(buffer, result); }
bool wasmMemoryArgument8InstructionRead__extern(Buffer *buffer, WasmMemoryArgumentInstruction *result) { return wasmMemoryArgument8InstructionRead(buffer, result); }
bool wasmMemoryArgument16InstructionRead__extern(Buffer *buffer, WasmMemoryArgumentInstruction *result) { return wasmMemoryArgument16InstructionRead(buffer, result); }
bool wasmMemoryArgument32InstructionRead__extern(Buffer *buffer, WasmMemoryArgumentInstruction *result) { return wasmMemoryArgument32InstructionRead(buffer, result); }
bool wasmMemoryArgument64InstructionRead__extern(Buffer *buffer, WasmMemoryArgumentInstruction *result) { return wasmMemoryArgument64InstructionRead(buffer, result); }
bool wasmLabelsEnsureCapacity__extern(WasmLabels *wasmLabels, size_t length) { return wasmLabelsEnsureCapacity(wasmLabels, length); }
bool wasmLabelsAppend__extern(WasmLabels *wasmLabels, WasmLabel label) { return wasmLabelsAppend(wasmLabels, label); }
void wasmLabelsFree__extern(WasmLabels *wasmLabels) { wasmLabelsFree(wasmLabels); }
void wasmLabelStackClear__extern(WasmLabelStack *labelStack) { wasmLabelStackClear(labelStack); }
bool wasmLabelStackPush__extern(WasmLabelStack *labelStack, const size_t typeStackLength, WasmValueType *type, WasmLabel *result) { return wasmLabelStackPush(labelStack, typeStackLength, type, result); }
void wasmLabelStackPop__extern(WasmLabelStack *labelStack) { wasmLabelStackPop(labelStack); }
U32 wasmLabelStackGetTopIndex__extern(const WasmLabelStack *labelStack, const U32 index) { return wasmLabelStackGetTopIndex(labelStack, index); }
bool stringBuilderAppend__extern(StringBuilder *stringBuilder, const char *string) { return stringBuilderAppend(stringBuilder, string); }
bool wasmTypeStackEnsureCapacity__extern(WasmTypeStack *wasmTypeStack, size_t length) { return wasmTypeStackEnsureCapacity(wasmTypeStack, length); }
bool wasmTypeStackAppend__extern(WasmTypeStack *wasmTypeStack, WasmValueType valueType) { return wasmTypeStackAppend(wasmTypeStack, valueType); }
void wasmTypeStackFree__extern(WasmTypeStack *wasmTypeStack) { wasmTypeStackFree(wasmTypeStack); }
void wasmTypeStackDrop__extern(WasmTypeStack *typeStack, size_t count) { wasmTypeStackDrop(typeStack, count); }
void wasmTypeStackClear__extern(WasmTypeStack *typeStack) { wasmTypeStackClear(typeStack); }
bool wasmTypeStackSet__extern(WasmTypeStack *typeStack, const U32 index, const WasmValueType valueType) { return wasmTypeStackSet(typeStack, index, valueType); }
bool wasmTypeStackIsSet__extern(const WasmTypeStack *typeStack, const U32 index, const WasmValueType valueType) { return wasmTypeStackIsSet(typeStack, index, valueType); }
U32 wasmTypeStackGetTopIndex__extern(const WasmTypeStack *typeStack, const U32 index) { return wasmTypeStackGetTopIndex(typeStack, index); }