chrome-devtools-frontend

  • Version 1.0.961797
  • Published
  • 85.3 MB
  • No dependencies
  • BSD-3-Clause license

Install

npm i chrome-devtools-frontend
yarn add chrome-devtools-frontend
pnpm add chrome-devtools-frontend

Overview

Chrome DevTools UI

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable OperatorCodeNames

const OperatorCodeNames: string[];

    Functions

    function bytesToString

    bytesToString: (bytes: Uint8Array) => string;

      Classes

      class BinaryReader

      class BinaryReader {}

        property data

        readonly data: Uint8Array;

          property error

          error: Error;

            property length

            readonly length: number;

              property position

              readonly position: number;

                property result

                result: BinaryReaderResult;

                  property state

                  state: BinaryReaderState;

                    method fetchSectionRawData

                    fetchSectionRawData: () => void;

                      method hasMoreBytes

                      hasMoreBytes: () => boolean;

                        method read

                        read: () => boolean;

                          method setData

                          setData: (
                          buffer: ArrayBuffer,
                          pos: number,
                          length: number,
                          eof?: boolean
                          ) => void;

                            method skipFunctionBody

                            skipFunctionBody: () => void;

                              method skipInitExpression

                              skipInitExpression: () => void;

                                method skipSection

                                skipSection: () => void;

                                  class DefaultNameResolver

                                  class DefaultNameResolver implements INameResolver {}

                                    method getElementName

                                    getElementName: (index: number, isRef: boolean) => string;

                                      method getEventName

                                      getEventName: (index: number, isRef: boolean) => string;

                                        method getFieldName

                                        getFieldName: (typeIndex: number, index: number, isRef: boolean) => string;

                                          method getFunctionName

                                          getFunctionName: (index: number, isImport: boolean, isRef: boolean) => string;

                                            method getGlobalName

                                            getGlobalName: (index: number, isRef: boolean) => string;

                                              method getLabel

                                              getLabel: (index: number) => string;

                                                method getMemoryName

                                                getMemoryName: (index: number, isRef: boolean) => string;

                                                  method getTableName

                                                  getTableName: (index: number, isRef: boolean) => string;

                                                    method getTypeName

                                                    getTypeName: (index: number, isRef: boolean) => string;

                                                      method getVariableName

                                                      getVariableName: (funcIndex: number, index: number, isRef: boolean) => string;

                                                        class Int64

                                                        class Int64 {}

                                                          constructor

                                                          constructor(data: Uint8Array);

                                                            property data

                                                            readonly data: Uint8Array;

                                                              method toDouble

                                                              toDouble: () => number;

                                                                method toInt32

                                                                toInt32: () => number;

                                                                  method toString

                                                                  toString: () => string;

                                                                    class NumericNameResolver

                                                                    class NumericNameResolver implements INameResolver {}

                                                                      method getElementName

                                                                      getElementName: (index: number, isRef: boolean) => string;

                                                                        method getEventName

                                                                        getEventName: (index: number, isRef: boolean) => string;

                                                                          method getFieldName

                                                                          getFieldName: (typeIndex: number, index: number, isRef: boolean) => string;

                                                                            method getFunctionName

                                                                            getFunctionName: (index: number, isImport: boolean, isRef: boolean) => string;

                                                                              method getGlobalName

                                                                              getGlobalName: (index: number, isRef: boolean) => string;

                                                                                method getLabel

                                                                                getLabel: (index: number) => string;

                                                                                  method getMemoryName

                                                                                  getMemoryName: (index: number, isRef: boolean) => string;

                                                                                    method getTableName

                                                                                    getTableName: (index: number, isRef: boolean) => string;

                                                                                      method getTypeName

                                                                                      getTypeName: (index: number, isRef: boolean) => string;

                                                                                        method getVariableName

                                                                                        getVariableName: (funcIndex: number, index: number, isRef: boolean) => string;

                                                                                          class Type

                                                                                          class Type {}

                                                                                            constructor

                                                                                            constructor(kind: TypeKind, index?: number, depth?: number);

                                                                                              property depth

                                                                                              depth: number;

                                                                                                property externref

                                                                                                static externref: Type;

                                                                                                  property funcref

                                                                                                  static funcref: Type;

                                                                                                    property index

                                                                                                    index: number;

                                                                                                      property kind

                                                                                                      kind: TypeKind;

                                                                                                        class WasmDisassembler

                                                                                                        class WasmDisassembler {}

                                                                                                          constructor

                                                                                                          constructor();

                                                                                                            property addOffsets

                                                                                                            addOffsets: boolean;

                                                                                                              property exportMetadata

                                                                                                              exportMetadata: IExportMetadata;

                                                                                                                property labelMode

                                                                                                                labelMode: LabelMode;

                                                                                                                  property nameResolver

                                                                                                                  nameResolver: INameResolver;

                                                                                                                    property skipTypes

                                                                                                                    skipTypes: boolean;

                                                                                                                      method disassemble

                                                                                                                      disassemble: (reader: BinaryReader) => string;

                                                                                                                        method disassembleChunk

                                                                                                                        disassembleChunk: (reader: BinaryReader, offsetInModule?: number) => boolean;

                                                                                                                          method getResult

                                                                                                                          getResult: () => IDisassemblerResult;

                                                                                                                            Interfaces

                                                                                                                            interface IBinaryReaderData

                                                                                                                            interface IBinaryReaderData {}

                                                                                                                              property result

                                                                                                                              result?: BinaryReaderResult;

                                                                                                                                property state

                                                                                                                                state: BinaryReaderState;

                                                                                                                                  interface IDataSegment

                                                                                                                                  interface IDataSegment {}

                                                                                                                                    property memoryIndex

                                                                                                                                    memoryIndex?: number;

                                                                                                                                      property mode

                                                                                                                                      mode: DataMode;

                                                                                                                                        interface IDataSegmentBody

                                                                                                                                        interface IDataSegmentBody {}

                                                                                                                                          property data

                                                                                                                                          data: Uint8Array;

                                                                                                                                            interface IDisassemblerResult

                                                                                                                                            interface IDisassemblerResult {}

                                                                                                                                              property done

                                                                                                                                              done: boolean;

                                                                                                                                                property functionBodyOffsets

                                                                                                                                                functionBodyOffsets?: Array<IFunctionBodyOffset>;

                                                                                                                                                  property lines

                                                                                                                                                  lines: Array<string>;

                                                                                                                                                    property offsets

                                                                                                                                                    offsets?: Array<number>;

                                                                                                                                                      interface IElementSegment

                                                                                                                                                      interface IElementSegment {}

                                                                                                                                                        property mode

                                                                                                                                                        mode: ElementMode;

                                                                                                                                                          property tableIndex

                                                                                                                                                          tableIndex?: number;

                                                                                                                                                            interface IElementSegmentBody

                                                                                                                                                            interface IElementSegmentBody {}

                                                                                                                                                              property elementType

                                                                                                                                                              elementType: Type;

                                                                                                                                                                interface IExportEntry

                                                                                                                                                                interface IExportEntry {}

                                                                                                                                                                  property field

                                                                                                                                                                  field: Uint8Array;

                                                                                                                                                                    property index

                                                                                                                                                                    index: number;

                                                                                                                                                                      property kind

                                                                                                                                                                      kind: ExternalKind;

                                                                                                                                                                        interface IFunctionEntry

                                                                                                                                                                        interface IFunctionEntry {}

                                                                                                                                                                          property typeIndex

                                                                                                                                                                          typeIndex: number;

                                                                                                                                                                            interface IFunctionInformation

                                                                                                                                                                            interface IFunctionInformation {}

                                                                                                                                                                              property locals

                                                                                                                                                                              locals: Array<ILocals>;

                                                                                                                                                                                interface IFunctionNameEntry

                                                                                                                                                                                interface IFunctionNameEntry extends INameEntry {}

                                                                                                                                                                                  property names

                                                                                                                                                                                  names: INaming[];

                                                                                                                                                                                    interface IGlobalType

                                                                                                                                                                                    interface IGlobalType {}

                                                                                                                                                                                      property contentType

                                                                                                                                                                                      contentType: Type;

                                                                                                                                                                                        property mutability

                                                                                                                                                                                        mutability: number;

                                                                                                                                                                                          interface IGlobalVariable

                                                                                                                                                                                          interface IGlobalVariable {}

                                                                                                                                                                                            property type

                                                                                                                                                                                            type: IGlobalType;

                                                                                                                                                                                              interface IImportEntry

                                                                                                                                                                                              interface IImportEntry {}

                                                                                                                                                                                                property field

                                                                                                                                                                                                field: Uint8Array;

                                                                                                                                                                                                  property funcTypeIndex

                                                                                                                                                                                                  funcTypeIndex?: number;

                                                                                                                                                                                                    property kind

                                                                                                                                                                                                    kind: ExternalKind;

                                                                                                                                                                                                      property module

                                                                                                                                                                                                      module: Uint8Array;

                                                                                                                                                                                                        property type

                                                                                                                                                                                                        type?: ImportEntryType;

                                                                                                                                                                                                          interface ILinkingEntry

                                                                                                                                                                                                          interface ILinkingEntry {}

                                                                                                                                                                                                            property index

                                                                                                                                                                                                            index?: number;

                                                                                                                                                                                                              property type

                                                                                                                                                                                                              type: LinkingType;

                                                                                                                                                                                                                interface ILocalName

                                                                                                                                                                                                                interface ILocalName {}

                                                                                                                                                                                                                  property index

                                                                                                                                                                                                                  index: number;

                                                                                                                                                                                                                    property locals

                                                                                                                                                                                                                    locals: INaming[];

                                                                                                                                                                                                                      interface ILocalNameEntry

                                                                                                                                                                                                                      interface ILocalNameEntry extends INameEntry {}

                                                                                                                                                                                                                        property funcs

                                                                                                                                                                                                                        funcs: ILocalName[];

                                                                                                                                                                                                                          interface ILocals

                                                                                                                                                                                                                          interface ILocals {}

                                                                                                                                                                                                                            property count

                                                                                                                                                                                                                            count: number;

                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                              type: Type;

                                                                                                                                                                                                                                interface IMemoryAddress

                                                                                                                                                                                                                                interface IMemoryAddress {}

                                                                                                                                                                                                                                  property flags

                                                                                                                                                                                                                                  flags: number;

                                                                                                                                                                                                                                    property offset

                                                                                                                                                                                                                                    offset: number;

                                                                                                                                                                                                                                      interface IMemoryType

                                                                                                                                                                                                                                      interface IMemoryType {}

                                                                                                                                                                                                                                        property limits

                                                                                                                                                                                                                                        limits: IResizableLimits;

                                                                                                                                                                                                                                          property shared

                                                                                                                                                                                                                                          shared: boolean;

                                                                                                                                                                                                                                            interface IModuleHeader

                                                                                                                                                                                                                                            interface IModuleHeader {}

                                                                                                                                                                                                                                              property magicNumber

                                                                                                                                                                                                                                              magicNumber: number;

                                                                                                                                                                                                                                                property version

                                                                                                                                                                                                                                                version: number;

                                                                                                                                                                                                                                                  interface IModuleNameEntry

                                                                                                                                                                                                                                                  interface IModuleNameEntry extends INameEntry {}

                                                                                                                                                                                                                                                    property moduleName

                                                                                                                                                                                                                                                    moduleName: Uint8Array;

                                                                                                                                                                                                                                                      interface INameEntry

                                                                                                                                                                                                                                                      interface INameEntry {}

                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                        type: NameType;

                                                                                                                                                                                                                                                          interface INameResolver

                                                                                                                                                                                                                                                          interface INameResolver {}

                                                                                                                                                                                                                                                            method getElementName

                                                                                                                                                                                                                                                            getElementName: (index: number, isRef: boolean) => string;

                                                                                                                                                                                                                                                              method getEventName

                                                                                                                                                                                                                                                              getEventName: (index: number, isRef: boolean) => string;

                                                                                                                                                                                                                                                                method getFieldName

                                                                                                                                                                                                                                                                getFieldName: (typeIndex: number, index: number, isRef: boolean) => string;

                                                                                                                                                                                                                                                                  method getFunctionName

                                                                                                                                                                                                                                                                  getFunctionName: (index: number, isImport: boolean, isRef: boolean) => string;

                                                                                                                                                                                                                                                                    method getGlobalName

                                                                                                                                                                                                                                                                    getGlobalName: (index: number, isRef: boolean) => string;

                                                                                                                                                                                                                                                                      method getLabel

                                                                                                                                                                                                                                                                      getLabel: (index: number) => string;

                                                                                                                                                                                                                                                                        method getMemoryName

                                                                                                                                                                                                                                                                        getMemoryName: (index: number, isRef: boolean) => string;

                                                                                                                                                                                                                                                                          method getTableName

                                                                                                                                                                                                                                                                          getTableName: (index: number, isRef: boolean) => string;

                                                                                                                                                                                                                                                                            method getTypeName

                                                                                                                                                                                                                                                                            getTypeName: (index: number, isRef: boolean) => string;

                                                                                                                                                                                                                                                                              method getVariableName

                                                                                                                                                                                                                                                                              getVariableName: (funcIndex: number, index: number, isRef: boolean) => string;

                                                                                                                                                                                                                                                                                interface INaming

                                                                                                                                                                                                                                                                                interface INaming {}

                                                                                                                                                                                                                                                                                  property index

                                                                                                                                                                                                                                                                                  index: number;

                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                    name: Uint8Array;

                                                                                                                                                                                                                                                                                      interface IOperatorInformation

                                                                                                                                                                                                                                                                                      interface IOperatorInformation {}

                                                                                                                                                                                                                                                                                        property blockType

                                                                                                                                                                                                                                                                                        blockType?: Type;

                                                                                                                                                                                                                                                                                          property brDepth

                                                                                                                                                                                                                                                                                          brDepth?: number;

                                                                                                                                                                                                                                                                                            property brTable

                                                                                                                                                                                                                                                                                            brTable?: Array<number>;

                                                                                                                                                                                                                                                                                              property code

                                                                                                                                                                                                                                                                                              code: OperatorCode;

                                                                                                                                                                                                                                                                                                property destinationIndex

                                                                                                                                                                                                                                                                                                destinationIndex?: number;

                                                                                                                                                                                                                                                                                                  property eventIndex

                                                                                                                                                                                                                                                                                                  eventIndex?: number;

                                                                                                                                                                                                                                                                                                    property fieldIndex

                                                                                                                                                                                                                                                                                                    fieldIndex?: number;

                                                                                                                                                                                                                                                                                                      property funcIndex

                                                                                                                                                                                                                                                                                                      funcIndex?: number;

                                                                                                                                                                                                                                                                                                        property globalIndex

                                                                                                                                                                                                                                                                                                        globalIndex?: number;

                                                                                                                                                                                                                                                                                                          property lineIndex

                                                                                                                                                                                                                                                                                                          lineIndex: number;

                                                                                                                                                                                                                                                                                                            property lines

                                                                                                                                                                                                                                                                                                            lines: Uint8Array;

                                                                                                                                                                                                                                                                                                              property literal

                                                                                                                                                                                                                                                                                                              literal?: number | Int64 | Uint8Array;

                                                                                                                                                                                                                                                                                                                property localIndex

                                                                                                                                                                                                                                                                                                                localIndex?: number;

                                                                                                                                                                                                                                                                                                                  property memoryAddress

                                                                                                                                                                                                                                                                                                                  memoryAddress?: IMemoryAddress;

                                                                                                                                                                                                                                                                                                                    property refType

                                                                                                                                                                                                                                                                                                                    refType?: number;

                                                                                                                                                                                                                                                                                                                      property relativeDepth

                                                                                                                                                                                                                                                                                                                      relativeDepth?: number;

                                                                                                                                                                                                                                                                                                                        property segmentIndex

                                                                                                                                                                                                                                                                                                                        segmentIndex?: number;

                                                                                                                                                                                                                                                                                                                          property selectType

                                                                                                                                                                                                                                                                                                                          selectType?: Type;

                                                                                                                                                                                                                                                                                                                            property srcType

                                                                                                                                                                                                                                                                                                                            srcType?: number;

                                                                                                                                                                                                                                                                                                                              property tableIndex

                                                                                                                                                                                                                                                                                                                              tableIndex?: number;

                                                                                                                                                                                                                                                                                                                                property typeIndex

                                                                                                                                                                                                                                                                                                                                typeIndex?: number;

                                                                                                                                                                                                                                                                                                                                  interface IRelocEntry

                                                                                                                                                                                                                                                                                                                                  interface IRelocEntry {}

                                                                                                                                                                                                                                                                                                                                    property addend

                                                                                                                                                                                                                                                                                                                                    addend?: number;

                                                                                                                                                                                                                                                                                                                                      property index

                                                                                                                                                                                                                                                                                                                                      index: number;

                                                                                                                                                                                                                                                                                                                                        property offset

                                                                                                                                                                                                                                                                                                                                        offset: number;

                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                          type: RelocType;

                                                                                                                                                                                                                                                                                                                                            interface IRelocHeader

                                                                                                                                                                                                                                                                                                                                            interface IRelocHeader {}

                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                              id: SectionCode;

                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                name: Uint8Array;

                                                                                                                                                                                                                                                                                                                                                  interface IResizableLimits

                                                                                                                                                                                                                                                                                                                                                  interface IResizableLimits {}

                                                                                                                                                                                                                                                                                                                                                    property initial

                                                                                                                                                                                                                                                                                                                                                    initial: number;

                                                                                                                                                                                                                                                                                                                                                      property maximum

                                                                                                                                                                                                                                                                                                                                                      maximum?: number;

                                                                                                                                                                                                                                                                                                                                                        interface ISectionInformation

                                                                                                                                                                                                                                                                                                                                                        interface ISectionInformation {}

                                                                                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                                                                                          id: SectionCode;

                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                            name: Uint8Array;

                                                                                                                                                                                                                                                                                                                                                              interface ISourceMappingURL

                                                                                                                                                                                                                                                                                                                                                              interface ISourceMappingURL {}

                                                                                                                                                                                                                                                                                                                                                                property url

                                                                                                                                                                                                                                                                                                                                                                url: Uint8Array;

                                                                                                                                                                                                                                                                                                                                                                  interface IStartEntry

                                                                                                                                                                                                                                                                                                                                                                  interface IStartEntry {}

                                                                                                                                                                                                                                                                                                                                                                    property index

                                                                                                                                                                                                                                                                                                                                                                    index: number;

                                                                                                                                                                                                                                                                                                                                                                      interface ITableType

                                                                                                                                                                                                                                                                                                                                                                      interface ITableType {}

                                                                                                                                                                                                                                                                                                                                                                        property elementType

                                                                                                                                                                                                                                                                                                                                                                        elementType: Type;

                                                                                                                                                                                                                                                                                                                                                                          property limits

                                                                                                                                                                                                                                                                                                                                                                          limits: IResizableLimits;

                                                                                                                                                                                                                                                                                                                                                                            interface ITypeEntry

                                                                                                                                                                                                                                                                                                                                                                            interface ITypeEntry {}

                                                                                                                                                                                                                                                                                                                                                                              property elementType

                                                                                                                                                                                                                                                                                                                                                                              elementType?: Type;

                                                                                                                                                                                                                                                                                                                                                                                property fields

                                                                                                                                                                                                                                                                                                                                                                                fields?: Type[];

                                                                                                                                                                                                                                                                                                                                                                                  property form

                                                                                                                                                                                                                                                                                                                                                                                  form: number;

                                                                                                                                                                                                                                                                                                                                                                                    property mutabilities

                                                                                                                                                                                                                                                                                                                                                                                    mutabilities?: boolean[];

                                                                                                                                                                                                                                                                                                                                                                                      property mutability

                                                                                                                                                                                                                                                                                                                                                                                      mutability?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                                                                                                                        params?: Type[];

                                                                                                                                                                                                                                                                                                                                                                                          property returns

                                                                                                                                                                                                                                                                                                                                                                                          returns?: Type[];

                                                                                                                                                                                                                                                                                                                                                                                            property supertype

                                                                                                                                                                                                                                                                                                                                                                                            supertype?: number;

                                                                                                                                                                                                                                                                                                                                                                                              Enums

                                                                                                                                                                                                                                                                                                                                                                                              enum BinaryReaderState

                                                                                                                                                                                                                                                                                                                                                                                              const enum BinaryReaderState {
                                                                                                                                                                                                                                                                                                                                                                                              ERROR = -1,
                                                                                                                                                                                                                                                                                                                                                                                              INITIAL = 0,
                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_WASM = 1,
                                                                                                                                                                                                                                                                                                                                                                                              END_WASM = 2,
                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_SECTION = 3,
                                                                                                                                                                                                                                                                                                                                                                                              END_SECTION = 4,
                                                                                                                                                                                                                                                                                                                                                                                              SKIPPING_SECTION = 5,
                                                                                                                                                                                                                                                                                                                                                                                              READING_SECTION_RAW_DATA = 6,
                                                                                                                                                                                                                                                                                                                                                                                              SECTION_RAW_DATA = 7,
                                                                                                                                                                                                                                                                                                                                                                                              TYPE_SECTION_ENTRY = 11,
                                                                                                                                                                                                                                                                                                                                                                                              IMPORT_SECTION_ENTRY = 12,
                                                                                                                                                                                                                                                                                                                                                                                              FUNCTION_SECTION_ENTRY = 13,
                                                                                                                                                                                                                                                                                                                                                                                              TABLE_SECTION_ENTRY = 14,
                                                                                                                                                                                                                                                                                                                                                                                              MEMORY_SECTION_ENTRY = 15,
                                                                                                                                                                                                                                                                                                                                                                                              GLOBAL_SECTION_ENTRY = 16,
                                                                                                                                                                                                                                                                                                                                                                                              EXPORT_SECTION_ENTRY = 17,
                                                                                                                                                                                                                                                                                                                                                                                              DATA_SECTION_ENTRY = 18,
                                                                                                                                                                                                                                                                                                                                                                                              NAME_SECTION_ENTRY = 19,
                                                                                                                                                                                                                                                                                                                                                                                              ELEMENT_SECTION_ENTRY = 20,
                                                                                                                                                                                                                                                                                                                                                                                              LINKING_SECTION_ENTRY = 21,
                                                                                                                                                                                                                                                                                                                                                                                              START_SECTION_ENTRY = 22,
                                                                                                                                                                                                                                                                                                                                                                                              EVENT_SECTION_ENTRY = 23,
                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_INIT_EXPRESSION_BODY = 25,
                                                                                                                                                                                                                                                                                                                                                                                              INIT_EXPRESSION_OPERATOR = 26,
                                                                                                                                                                                                                                                                                                                                                                                              END_INIT_EXPRESSION_BODY = 27,
                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_FUNCTION_BODY = 28,
                                                                                                                                                                                                                                                                                                                                                                                              READING_FUNCTION_HEADER = 29,
                                                                                                                                                                                                                                                                                                                                                                                              CODE_OPERATOR = 30,
                                                                                                                                                                                                                                                                                                                                                                                              END_FUNCTION_BODY = 31,
                                                                                                                                                                                                                                                                                                                                                                                              SKIPPING_FUNCTION_BODY = 32,
                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_ELEMENT_SECTION_ENTRY = 33,
                                                                                                                                                                                                                                                                                                                                                                                              ELEMENT_SECTION_ENTRY_BODY = 34,
                                                                                                                                                                                                                                                                                                                                                                                              END_ELEMENT_SECTION_ENTRY = 35,
                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_DATA_SECTION_ENTRY = 36,
                                                                                                                                                                                                                                                                                                                                                                                              DATA_SECTION_ENTRY_BODY = 37,
                                                                                                                                                                                                                                                                                                                                                                                              END_DATA_SECTION_ENTRY = 38,
                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_GLOBAL_SECTION_ENTRY = 39,
                                                                                                                                                                                                                                                                                                                                                                                              END_GLOBAL_SECTION_ENTRY = 40,
                                                                                                                                                                                                                                                                                                                                                                                              RELOC_SECTION_HEADER = 41,
                                                                                                                                                                                                                                                                                                                                                                                              RELOC_SECTION_ENTRY = 42,
                                                                                                                                                                                                                                                                                                                                                                                              SOURCE_MAPPING_URL = 43,
                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_OFFSET_EXPRESSION_BODY = 44,
                                                                                                                                                                                                                                                                                                                                                                                              OFFSET_EXPRESSION_OPERATOR = 45,
                                                                                                                                                                                                                                                                                                                                                                                              END_OFFSET_EXPRESSION_BODY = 46,
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                member BEGIN_DATA_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                BEGIN_DATA_SECTION_ENTRY = 36

                                                                                                                                                                                                                                                                                                                                                                                                  member BEGIN_ELEMENT_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                  BEGIN_ELEMENT_SECTION_ENTRY = 33

                                                                                                                                                                                                                                                                                                                                                                                                    member BEGIN_FUNCTION_BODY

                                                                                                                                                                                                                                                                                                                                                                                                    BEGIN_FUNCTION_BODY = 28

                                                                                                                                                                                                                                                                                                                                                                                                      member BEGIN_GLOBAL_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                      BEGIN_GLOBAL_SECTION_ENTRY = 39

                                                                                                                                                                                                                                                                                                                                                                                                        member BEGIN_INIT_EXPRESSION_BODY

                                                                                                                                                                                                                                                                                                                                                                                                        BEGIN_INIT_EXPRESSION_BODY = 25

                                                                                                                                                                                                                                                                                                                                                                                                          member BEGIN_OFFSET_EXPRESSION_BODY

                                                                                                                                                                                                                                                                                                                                                                                                          BEGIN_OFFSET_EXPRESSION_BODY = 44

                                                                                                                                                                                                                                                                                                                                                                                                            member BEGIN_SECTION

                                                                                                                                                                                                                                                                                                                                                                                                            BEGIN_SECTION = 3

                                                                                                                                                                                                                                                                                                                                                                                                              member BEGIN_WASM

                                                                                                                                                                                                                                                                                                                                                                                                              BEGIN_WASM = 1

                                                                                                                                                                                                                                                                                                                                                                                                                member CODE_OPERATOR

                                                                                                                                                                                                                                                                                                                                                                                                                CODE_OPERATOR = 30

                                                                                                                                                                                                                                                                                                                                                                                                                  member DATA_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                  DATA_SECTION_ENTRY = 18

                                                                                                                                                                                                                                                                                                                                                                                                                    member DATA_SECTION_ENTRY_BODY

                                                                                                                                                                                                                                                                                                                                                                                                                    DATA_SECTION_ENTRY_BODY = 37

                                                                                                                                                                                                                                                                                                                                                                                                                      member ELEMENT_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                      ELEMENT_SECTION_ENTRY = 20

                                                                                                                                                                                                                                                                                                                                                                                                                        member ELEMENT_SECTION_ENTRY_BODY

                                                                                                                                                                                                                                                                                                                                                                                                                        ELEMENT_SECTION_ENTRY_BODY = 34

                                                                                                                                                                                                                                                                                                                                                                                                                          member END_DATA_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                          END_DATA_SECTION_ENTRY = 38

                                                                                                                                                                                                                                                                                                                                                                                                                            member END_ELEMENT_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                            END_ELEMENT_SECTION_ENTRY = 35

                                                                                                                                                                                                                                                                                                                                                                                                                              member END_FUNCTION_BODY

                                                                                                                                                                                                                                                                                                                                                                                                                              END_FUNCTION_BODY = 31

                                                                                                                                                                                                                                                                                                                                                                                                                                member END_GLOBAL_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                END_GLOBAL_SECTION_ENTRY = 40

                                                                                                                                                                                                                                                                                                                                                                                                                                  member END_INIT_EXPRESSION_BODY

                                                                                                                                                                                                                                                                                                                                                                                                                                  END_INIT_EXPRESSION_BODY = 27

                                                                                                                                                                                                                                                                                                                                                                                                                                    member END_OFFSET_EXPRESSION_BODY

                                                                                                                                                                                                                                                                                                                                                                                                                                    END_OFFSET_EXPRESSION_BODY = 46

                                                                                                                                                                                                                                                                                                                                                                                                                                      member END_SECTION

                                                                                                                                                                                                                                                                                                                                                                                                                                      END_SECTION = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                        member END_WASM

                                                                                                                                                                                                                                                                                                                                                                                                                                        END_WASM = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                          member ERROR

                                                                                                                                                                                                                                                                                                                                                                                                                                          ERROR = -1

                                                                                                                                                                                                                                                                                                                                                                                                                                            member EVENT_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                            EVENT_SECTION_ENTRY = 23

                                                                                                                                                                                                                                                                                                                                                                                                                                              member EXPORT_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                              EXPORT_SECTION_ENTRY = 17

                                                                                                                                                                                                                                                                                                                                                                                                                                                member FUNCTION_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                FUNCTION_SECTION_ENTRY = 13

                                                                                                                                                                                                                                                                                                                                                                                                                                                  member GLOBAL_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                  GLOBAL_SECTION_ENTRY = 16

                                                                                                                                                                                                                                                                                                                                                                                                                                                    member IMPORT_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                    IMPORT_SECTION_ENTRY = 12

                                                                                                                                                                                                                                                                                                                                                                                                                                                      member INIT_EXPRESSION_OPERATOR

                                                                                                                                                                                                                                                                                                                                                                                                                                                      INIT_EXPRESSION_OPERATOR = 26

                                                                                                                                                                                                                                                                                                                                                                                                                                                        member INITIAL

                                                                                                                                                                                                                                                                                                                                                                                                                                                        INITIAL = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                          member LINKING_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                          LINKING_SECTION_ENTRY = 21

                                                                                                                                                                                                                                                                                                                                                                                                                                                            member MEMORY_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                            MEMORY_SECTION_ENTRY = 15

                                                                                                                                                                                                                                                                                                                                                                                                                                                              member NAME_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                              NAME_SECTION_ENTRY = 19

                                                                                                                                                                                                                                                                                                                                                                                                                                                                member OFFSET_EXPRESSION_OPERATOR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                OFFSET_EXPRESSION_OPERATOR = 45

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member READING_FUNCTION_HEADER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  READING_FUNCTION_HEADER = 29

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member READING_SECTION_RAW_DATA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    READING_SECTION_RAW_DATA = 6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member RELOC_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RELOC_SECTION_ENTRY = 42

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member RELOC_SECTION_HEADER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RELOC_SECTION_HEADER = 41

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member SECTION_RAW_DATA

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SECTION_RAW_DATA = 7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member SKIPPING_FUNCTION_BODY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SKIPPING_FUNCTION_BODY = 32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member SKIPPING_SECTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SKIPPING_SECTION = 5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member SOURCE_MAPPING_URL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SOURCE_MAPPING_URL = 43

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member START_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  START_SECTION_ENTRY = 22

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member TABLE_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TABLE_SECTION_ENTRY = 14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member TYPE_SECTION_ENTRY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TYPE_SECTION_ENTRY = 11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ExternalKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const enum ExternalKind {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Function = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Table = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Memory = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Global = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Event = 4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Event = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Global

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Global = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Memory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Memory = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Table = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum LabelMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum LabelMode {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Depth,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    WhenUsed,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Always,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Always

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Always

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member WhenUsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WhenUsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enum LinkingType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const enum LinkingType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            StackPointer = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member StackPointer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              StackPointer = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                enum NameType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const enum NameType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Module = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Function = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Local = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Event = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Type = 4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Table = 5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Memory = 6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Global = 7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Field = 10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Event = 3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Field = 10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Function = 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Global

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Global = 7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Local

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Local = 2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Memory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Memory = 6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Module

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Module = 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Table = 5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type = 4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum OperatorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const enum OperatorCode {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unreachable = 0x00,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nop = 0x01,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    block = 0x02,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loop = 0x03,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if = 0x04,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    else = 0x05,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    try = 0x06,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    catch = 0x07,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    throw = 0x08,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rethrow = 0x09,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unwind = 0x0a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    end = 0x0b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br = 0x0c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_if = 0x0d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_table = 0x0e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return = 0x0f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call = 0x10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call_indirect = 0x11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return_call = 0x12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return_call_indirect = 0x13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call_ref = 0x14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return_call_ref = 0x15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    let = 0x17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    delegate = 0x18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    catch_all = 0x19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    drop = 0x1a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    select = 0x1b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    select_with_type = 0x1c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    local_get = 0x20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    local_set = 0x21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    local_tee = 0x22,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    global_get = 0x23,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    global_set = 0x24,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_load = 0x28,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_load = 0x29,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_load = 0x2a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_load = 0x2b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_load8_s = 0x2c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_load8_u = 0x2d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_load16_s = 0x2e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_load16_u = 0x2f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_load8_s = 0x30,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_load8_u = 0x31,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_load16_s = 0x32,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_load16_u = 0x33,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_load32_s = 0x34,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_load32_u = 0x35,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_store = 0x36,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_store = 0x37,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_store = 0x38,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_store = 0x39,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_store8 = 0x3a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_store16 = 0x3b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_store8 = 0x3c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_store16 = 0x3d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_store32 = 0x3e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    current_memory = 0x3f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    grow_memory = 0x40,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_const = 0x41,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_const = 0x42,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_const = 0x43,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_const = 0x44,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_eqz = 0x45,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_eq = 0x46,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_ne = 0x47,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_lt_s = 0x48,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_lt_u = 0x49,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_gt_s = 0x4a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_gt_u = 0x4b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_le_s = 0x4c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_le_u = 0x4d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_ge_s = 0x4e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_ge_u = 0x4f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_eqz = 0x50,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_eq = 0x51,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_ne = 0x52,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_lt_s = 0x53,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_lt_u = 0x54,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_gt_s = 0x55,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_gt_u = 0x56,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_le_s = 0x57,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_le_u = 0x58,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_ge_s = 0x59,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_ge_u = 0x5a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_eq = 0x5b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_ne = 0x5c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_lt = 0x5d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_gt = 0x5e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_le = 0x5f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_ge = 0x60,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_eq = 0x61,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_ne = 0x62,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_lt = 0x63,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_gt = 0x64,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_le = 0x65,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_ge = 0x66,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_clz = 0x67,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_ctz = 0x68,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_popcnt = 0x69,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_add = 0x6a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_sub = 0x6b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_mul = 0x6c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_div_s = 0x6d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_div_u = 0x6e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_rem_s = 0x6f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_rem_u = 0x70,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_and = 0x71,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_or = 0x72,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_xor = 0x73,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_shl = 0x74,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_shr_s = 0x75,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_shr_u = 0x76,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_rotl = 0x77,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_rotr = 0x78,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_clz = 0x79,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_ctz = 0x7a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_popcnt = 0x7b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_add = 0x7c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_sub = 0x7d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_mul = 0x7e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_div_s = 0x7f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_div_u = 0x80,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_rem_s = 0x81,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_rem_u = 0x82,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_and = 0x83,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_or = 0x84,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_xor = 0x85,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_shl = 0x86,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_shr_s = 0x87,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_shr_u = 0x88,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_rotl = 0x89,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_rotr = 0x8a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_abs = 0x8b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_neg = 0x8c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_ceil = 0x8d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_floor = 0x8e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_trunc = 0x8f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_nearest = 0x90,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_sqrt = 0x91,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_add = 0x92,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_sub = 0x93,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_mul = 0x94,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_div = 0x95,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_min = 0x96,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_max = 0x97,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_copysign = 0x98,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_abs = 0x99,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_neg = 0x9a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_ceil = 0x9b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_floor = 0x9c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_trunc = 0x9d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_nearest = 0x9e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_sqrt = 0x9f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_add = 0xa0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_sub = 0xa1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_mul = 0xa2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_div = 0xa3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_min = 0xa4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_max = 0xa5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_copysign = 0xa6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_wrap_i64 = 0xa7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_f32_s = 0xa8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_f32_u = 0xa9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_f64_s = 0xaa,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_f64_u = 0xab,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_extend_i32_s = 0xac,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_extend_i32_u = 0xad,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_trunc_f32_s = 0xae,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_trunc_f32_u = 0xaf,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_trunc_f64_s = 0xb0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_trunc_f64_u = 0xb1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_convert_i32_s = 0xb2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_convert_i32_u = 0xb3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_convert_i64_s = 0xb4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_convert_i64_u = 0xb5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_demote_f64 = 0xb6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_convert_i32_s = 0xb7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_convert_i32_u = 0xb8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_convert_i64_s = 0xb9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_convert_i64_u = 0xba,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_promote_f32 = 0xbb,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_reinterpret_f32 = 0xbc,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_reinterpret_f64 = 0xbd,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_reinterpret_i32 = 0xbe,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_reinterpret_i64 = 0xbf,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_extend8_s = 0xc0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_extend16_s = 0xc1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_extend8_s = 0xc2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_extend16_s = 0xc3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_extend32_s = 0xc4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prefix_0xfb = 0xfb,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prefix_0xfc = 0xfc,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prefix_0xfd = 0xfd,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prefix_0xfe = 0xfe,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_sat_f32_s = 0xfc00,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_sat_f32_u = 0xfc01,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_sat_f64_s = 0xfc02,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_sat_f64_u = 0xfc03,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_trunc_sat_f32_s = 0xfc04,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_trunc_sat_f32_u = 0xfc05,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_trunc_sat_f64_s = 0xfc06,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_trunc_sat_f64_u = 0xfc07,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    memory_init = 0xfc08,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data_drop = 0xfc09,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    memory_copy = 0xfc0a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    memory_fill = 0xfc0b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    table_init = 0xfc0c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    elem_drop = 0xfc0d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    table_copy = 0xfc0e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    table_grow = 0xfc0f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    table_size = 0xfc10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    table_fill = 0xfc11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    table_get = 0x25,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    table_set = 0x26,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_null = 0xd0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_is_null = 0xd1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_func = 0xd2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_as_non_null = 0xd3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_null = 0xd4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_eq = 0xd5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_non_null = 0xd6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    atomic_notify = 0xfe00,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_wait = 0xfe01,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_wait = 0xfe02,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    atomic_fence = 0xfe03,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_load = 0xfe10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_load = 0xfe11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_load8_u = 0xfe12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_load16_u = 0xfe13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_load8_u = 0xfe14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_load16_u = 0xfe15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_load32_u = 0xfe16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_store = 0xfe17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_store = 0xfe18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_store8 = 0xfe19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_store16 = 0xfe1a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_store8 = 0xfe1b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_store16 = 0xfe1c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_store32 = 0xfe1d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw_add = 0xfe1e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw_add = 0xfe1f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw8_add_u = 0xfe20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw16_add_u = 0xfe21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw8_add_u = 0xfe22,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw16_add_u = 0xfe23,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw32_add_u = 0xfe24,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw_sub = 0xfe25,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw_sub = 0xfe26,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw8_sub_u = 0xfe27,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw16_sub_u = 0xfe28,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw8_sub_u = 0xfe29,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw16_sub_u = 0xfe2a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw32_sub_u = 0xfe2b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw_and = 0xfe2c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw_and = 0xfe2d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw8_and_u = 0xfe2e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw16_and_u = 0xfe2f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw8_and_u = 0xfe30,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw16_and_u = 0xfe31,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw32_and_u = 0xfe32,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw_or = 0xfe33,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw_or = 0xfe34,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw8_or_u = 0xfe35,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw16_or_u = 0xfe36,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw8_or_u = 0xfe37,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw16_or_u = 0xfe38,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw32_or_u = 0xfe39,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw_xor = 0xfe3a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw_xor = 0xfe3b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw8_xor_u = 0xfe3c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw16_xor_u = 0xfe3d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw8_xor_u = 0xfe3e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw16_xor_u = 0xfe3f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw32_xor_u = 0xfe40,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw_xchg = 0xfe41,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw_xchg = 0xfe42,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw8_xchg_u = 0xfe43,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw16_xchg_u = 0xfe44,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw8_xchg_u = 0xfe45,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw16_xchg_u = 0xfe46,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw32_xchg_u = 0xfe47,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw_cmpxchg = 0xfe48,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw_cmpxchg = 0xfe49,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw8_cmpxchg_u = 0xfe4a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw16_cmpxchg_u = 0xfe4b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw8_cmpxchg_u = 0xfe4c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw16_cmpxchg_u = 0xfe4d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64_atomic_rmw32_cmpxchg_u = 0xfe4e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_load = 0xfd00,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_load8x8_s = 0xfd01,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_load8x8_u = 0xfd02,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_load16x4_s = 0xfd03,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_load16x4_u = 0xfd04,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_load32x2_s = 0xfd05,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_load32x2_u = 0xfd06,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v8x16_load_splat = 0xfd07,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v16x8_load_splat = 0xfd08,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v32x4_load_splat = 0xfd09,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v64x2_load_splat = 0xfd0a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_store = 0xfd0b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_const = 0xfd0c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_shuffle = 0xfd0d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_swizzle = 0xfd0e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_splat = 0xfd0f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_splat = 0xfd10,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_splat = 0xfd11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_splat = 0xfd12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_splat = 0xfd13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_splat = 0xfd14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_extract_lane_s = 0xfd15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_extract_lane_u = 0xfd16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_replace_lane = 0xfd17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extract_lane_s = 0xfd18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extract_lane_u = 0xfd19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_replace_lane = 0xfd1a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extract_lane = 0xfd1b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_replace_lane = 0xfd1c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extract_lane = 0xfd1d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_replace_lane = 0xfd1e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_extract_lane = 0xfd1f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_replace_lane = 0xfd20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_extract_lane = 0xfd21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_replace_lane = 0xfd22,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_eq = 0xfd23,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_ne = 0xfd24,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_lt_s = 0xfd25,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_lt_u = 0xfd26,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_gt_s = 0xfd27,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_gt_u = 0xfd28,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_le_s = 0xfd29,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_le_u = 0xfd2a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_ge_s = 0xfd2b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_ge_u = 0xfd2c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_eq = 0xfd2d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_ne = 0xfd2e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_lt_s = 0xfd2f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_lt_u = 0xfd30,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_gt_s = 0xfd31,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_gt_u = 0xfd32,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_le_s = 0xfd33,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_le_u = 0xfd34,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_ge_s = 0xfd35,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_ge_u = 0xfd36,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_eq = 0xfd37,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_ne = 0xfd38,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_lt_s = 0xfd39,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_lt_u = 0xfd3a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_gt_s = 0xfd3b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_gt_u = 0xfd3c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_le_s = 0xfd3d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_le_u = 0xfd3e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_ge_s = 0xfd3f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_ge_u = 0xfd40,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_eq = 0xfd41,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_ne = 0xfd42,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_lt = 0xfd43,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_gt = 0xfd44,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_le = 0xfd45,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_ge = 0xfd46,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_eq = 0xfd47,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_ne = 0xfd48,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_lt = 0xfd49,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_gt = 0xfd4a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_le = 0xfd4b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_ge = 0xfd4c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_not = 0xfd4d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_and = 0xfd4e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_andnot = 0xfd4f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_or = 0xfd50,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_xor = 0xfd51,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_bitselect = 0xfd52,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_any_true = 0xfd53,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_load8_lane = 0xfd54,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_load16_lane = 0xfd55,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_load32_lane = 0xfd56,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_load64_lane = 0xfd57,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_store8_lane = 0xfd58,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_store16_lane = 0xfd59,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_store32_lane = 0xfd5a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_store64_lane = 0xfd5b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_load32_zero = 0xfd5c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    v128_load64_zero = 0xfd5d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_demote_f64x2_zero = 0xfd5e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_promote_low_f32x4 = 0xfd5f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_abs = 0xfd60,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_neg = 0xfd61,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_popcnt = 0xfd62,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_all_true = 0xfd63,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_bitmask = 0xfd64,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_narrow_i16x8_s = 0xfd65,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_narrow_i16x8_u = 0xfd66,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_ceil = 0xfd67,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_floor = 0xfd68,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_trunc = 0xfd69,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_nearest = 0xfd6a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_shl = 0xfd6b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_shr_s = 0xfd6c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_shr_u = 0xfd6d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_add = 0xfd6e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_add_sat_s = 0xfd6f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_add_sat_u = 0xfd70,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_sub = 0xfd71,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_sub_sat_s = 0xfd72,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_sub_sat_u = 0xfd73,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_ceil = 0xfd74,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_floor = 0xfd75,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_min_s = 0xfd76,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_min_u = 0xfd77,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_max_s = 0xfd78,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_max_u = 0xfd79,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_trunc = 0xfd7a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i8x16_avgr_u = 0xfd7b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extadd_pairwise_i8x16_s = 0xfd7c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extadd_pairwise_i8x16_u = 0xfd7d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extadd_pairwise_i16x8_s = 0xfd7e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extadd_pairwise_i16x8_u = 0xfd7f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_abs = 0xfd80,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_neg = 0xfd81,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_q15mulr_sat_s = 0xfd82,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_all_true = 0xfd83,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_bitmask = 0xfd84,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_narrow_i32x4_s = 0xfd85,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_narrow_i32x4_u = 0xfd86,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extend_low_i8x16_s = 0xfd87,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extend_high_i8x16_s = 0xfd88,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extend_low_i8x16_u = 0xfd89,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extend_high_i8x16_u = 0xfd8a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_shl = 0xfd8b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_shr_s = 0xfd8c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_shr_u = 0xfd8d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_add = 0xfd8e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_add_sat_s = 0xfd8f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_add_sat_u = 0xfd90,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_sub = 0xfd91,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_sub_sat_s = 0xfd92,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_sub_sat_u = 0xfd93,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_nearest = 0xfd94,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_mul = 0xfd95,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_min_s = 0xfd96,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_min_u = 0xfd97,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_max_s = 0xfd98,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_max_u = 0xfd99,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_avgr_u = 0xfd9b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extmul_low_i8x16_s = 0xfd9c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extmul_high_i8x16_s = 0xfd9d,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extmul_low_i8x16_u = 0xfd9e,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extmul_high_i8x16_u = 0xfd9f,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_abs = 0xfda0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_neg = 0xfda1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_all_true = 0xfda3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_bitmask = 0xfda4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extend_low_i16x8_s = 0xfda7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extend_high_i16x8_s = 0xfda8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extend_low_i16x8_u = 0xfda9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extend_high_i16x8_u = 0xfdaa,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_shl = 0xfdab,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_shr_s = 0xfdac,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_shr_u = 0xfdad,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_add = 0xfdae,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_sub = 0xfdb1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_mul = 0xfdb5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_min_s = 0xfdb6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_min_u = 0xfdb7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_max_s = 0xfdb8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_max_u = 0xfdb9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_dot_i16x8_s = 0xfdba,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extmul_low_i16x8_s = 0xfdbc,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extmul_high_i16x8_s = 0xfdbd,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extmul_low_i16x8_u = 0xfdbe,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extmul_high_i16x8_u = 0xfdbf,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_abs = 0xfdc0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_neg = 0xfdc1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_all_true = 0xfdc3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_bitmask = 0xfdc4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extend_low_i32x4_s = 0xfdc7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extend_high_i32x4_s = 0xfdc8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extend_low_i32x4_u = 0xfdc9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extend_high_i32x4_u = 0xfdca,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_shl = 0xfdcb,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_shr_s = 0xfdcc,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_shr_u = 0xfdcd,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_add = 0xfdce,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_sub = 0xfdd1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_mul = 0xfdd5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_eq = 0xfdd6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_ne = 0xfdd7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_lt_s = 0xfdd8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_gt_s = 0xfdd9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_le_s = 0xfdda,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_ge_s = 0xfddb,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extmul_low_i32x4_s = 0xfddc,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extmul_high_i32x4_s = 0xfddd,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extmul_low_i32x4_u = 0xfdde,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i64x2_extmul_high_i32x4_u = 0xfddf,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_abs = 0xfde0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_neg = 0xfde1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_sqrt = 0xfde3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_add = 0xfde4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_sub = 0xfde5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_mul = 0xfde6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_div = 0xfde7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_min = 0xfde8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_max = 0xfde9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_pmin = 0xfdea,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_pmax = 0xfdeb,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_abs = 0xfdec,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_neg = 0xfded,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_sqrt = 0xfdef,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_add = 0xfdf0,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_sub = 0xfdf1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_mul = 0xfdf2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_div = 0xfdf3,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_min = 0xfdf4,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_max = 0xfdf5,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_pmin = 0xfdf6,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_pmax = 0xfdf7,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_trunc_sat_f32x4_s = 0xfdf8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_trunc_sat_f32x4_u = 0xfdf9,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_convert_i32x4_s = 0xfdfa,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_convert_i32x4_u = 0xfdfb,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_trunc_sat_f64x2_s_zero = 0xfdfc,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_trunc_sat_f64x2_u_zero = 0xfdfd,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_convert_low_i32x4_s = 0xfdfe,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_convert_low_i32x4_u = 0xfdff,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    struct_new_with_rtt = 0xfb01,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    struct_new_default_with_rtt = 0xfb02,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    struct_get = 0xfb03,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    struct_get_s = 0xfb04,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    struct_get_u = 0xfb05,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    struct_set = 0xfb06,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    struct_new = 0xfb07,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    struct_new_default = 0xfb08,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_new_with_rtt = 0xfb11,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_new_default_with_rtt = 0xfb12,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_get = 0xfb13,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_get_s = 0xfb14,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_get_u = 0xfb15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_set = 0xfb16,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_len = 0xfb17,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_copy = 0xfb18,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_init = 0xfb19,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_init_static = 0xfb1a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_new = 0xfb1b,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_new_default = 0xfb1c,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i31_new = 0xfb20,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i31_get_s = 0xfb21,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i31_get_u = 0xfb22,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rtt_canon = 0xfb30,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rtt_sub = 0xfb31,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rtt_fresh_sub = 0xfb32,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_test = 0xfb40,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_test_static = 0xfb44,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_cast = 0xfb41,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_cast_static = 0xfb45,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_cast = 0xfb42,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_cast_static = 0xfb46,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_cast_fail = 0xfb43,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_cast_static_fail = 0xfb47,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_is_func = 0xfb50,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_is_data = 0xfb51,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_is_i31 = 0xfb52,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_as_func = 0xfb58,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_as_data = 0xfb59,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref_as_i31 = 0xfb5a,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_func = 0xfb60,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_data = 0xfb61,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_i31 = 0xfb62,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_non_func = 0xfb63,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_non_data = 0xfb64,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_non_i31 = 0xfb65,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member array_copy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      array_copy = 0xfb18

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member array_get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        array_get = 0xfb13

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member array_get_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          array_get_s = 0xfb14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member array_get_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            array_get_u = 0xfb15

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member array_init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              array_init = 0xfb19

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member array_init_static

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                array_init_static = 0xfb1a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member array_len

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  array_len = 0xfb17

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member array_new

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    array_new = 0xfb1b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member array_new_default

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      array_new_default = 0xfb1c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member array_new_default_with_rtt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        array_new_default_with_rtt = 0xfb12

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member array_new_with_rtt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          array_new_with_rtt = 0xfb11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member array_set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            array_set = 0xfb16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member atomic_fence

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              atomic_fence = 0xfe03

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member atomic_notify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                atomic_notify = 0xfe00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  block = 0x02

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member br

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br = 0x0c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member br_if

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      br_if = 0x0d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member br_on_cast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        br_on_cast = 0xfb42

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member br_on_cast_fail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          br_on_cast_fail = 0xfb43

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member br_on_cast_static

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            br_on_cast_static = 0xfb46

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member br_on_cast_static_fail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              br_on_cast_static_fail = 0xfb47

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member br_on_data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                br_on_data = 0xfb61

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member br_on_func

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  br_on_func = 0xfb60

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member br_on_i31

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    br_on_i31 = 0xfb62

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member br_on_non_data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      br_on_non_data = 0xfb64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member br_on_non_func

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        br_on_non_func = 0xfb63

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member br_on_non_i31

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          br_on_non_i31 = 0xfb65

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member br_on_non_null

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            br_on_non_null = 0xd6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member br_on_null

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              br_on_null = 0xd4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member br_table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                br_table = 0x0e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call = 0x10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member call_indirect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call_indirect = 0x11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member call_ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call_ref = 0x14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member catch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        catch = 0x07

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member catch_all

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          catch_all = 0x19

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member current_memory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            current_memory = 0x3f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member data_drop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data_drop = 0xfc09

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member delegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                delegate = 0x18

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member drop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  drop = 0x1a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member elem_drop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    elem_drop = 0xfc0d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member else

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      else = 0x05

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        end = 0x0b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f32_abs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f32_abs = 0x8b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f32_add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f32_add = 0x92

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f32_ceil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f32_ceil = 0x8d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f32_const

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f32_const = 0x43

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f32_convert_i32_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f32_convert_i32_s = 0xb2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f32_convert_i32_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_convert_i32_u = 0xb3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f32_convert_i64_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f32_convert_i64_s = 0xb4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f32_convert_i64_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f32_convert_i64_u = 0xb5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f32_copysign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f32_copysign = 0x98

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f32_demote_f64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f32_demote_f64 = 0xb6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f32_div

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f32_div = 0x95

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f32_eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f32_eq = 0x5b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f32_floor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f32_floor = 0x8e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f32_ge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_ge = 0x60

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f32_gt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f32_gt = 0x5e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f32_le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f32_le = 0x5f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f32_load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f32_load = 0x2a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f32_lt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f32_lt = 0x5d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f32_max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f32_max = 0x97

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f32_min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f32_min = 0x96

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f32_mul

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f32_mul = 0x94

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f32_ne

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32_ne = 0x5c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f32_nearest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f32_nearest = 0x90

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f32_neg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f32_neg = 0x8c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f32_reinterpret_i32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f32_reinterpret_i32 = 0xbe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f32_sqrt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f32_sqrt = 0x91

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f32_store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f32_store = 0x38

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f32_sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f32_sub = 0x93

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f32_trunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f32_trunc = 0x8f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f32x4_abs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_abs = 0xfde0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f32x4_add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f32x4_add = 0xfde4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f32x4_ceil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f32x4_ceil = 0xfd67

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f32x4_convert_i32x4_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f32x4_convert_i32x4_s = 0xfdfa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f32x4_convert_i32x4_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f32x4_convert_i32x4_u = 0xfdfb

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f32x4_demote_f64x2_zero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f32x4_demote_f64x2_zero = 0xfd5e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f32x4_div

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f32x4_div = 0xfde7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f32x4_eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f32x4_eq = 0xfd41

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f32x4_extract_lane

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_extract_lane = 0xfd1f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f32x4_floor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f32x4_floor = 0xfd68

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f32x4_ge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f32x4_ge = 0xfd46

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f32x4_gt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f32x4_gt = 0xfd44

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f32x4_le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f32x4_le = 0xfd45

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f32x4_lt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f32x4_lt = 0xfd43

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f32x4_max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f32x4_max = 0xfde9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f32x4_min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f32x4_min = 0xfde8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f32x4_mul

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_mul = 0xfde6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f32x4_ne

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f32x4_ne = 0xfd42

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f32x4_nearest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f32x4_nearest = 0xfd6a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f32x4_neg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f32x4_neg = 0xfde1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f32x4_pmax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f32x4_pmax = 0xfdeb

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f32x4_pmin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f32x4_pmin = 0xfdea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f32x4_replace_lane

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f32x4_replace_lane = 0xfd20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f32x4_splat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f32x4_splat = 0xfd13

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f32x4_sqrt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f32x4_sqrt = 0xfde3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f32x4_sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f32x4_sub = 0xfde5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f32x4_trunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f32x4_trunc = 0xfd69

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f64_abs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f64_abs = 0x99

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f64_add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f64_add = 0xa0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f64_ceil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f64_ceil = 0x9b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f64_const

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f64_const = 0x44

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f64_convert_i32_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f64_convert_i32_s = 0xb7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f64_convert_i32_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_convert_i32_u = 0xb8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f64_convert_i64_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f64_convert_i64_s = 0xb9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f64_convert_i64_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f64_convert_i64_u = 0xba

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f64_copysign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f64_copysign = 0xa6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f64_div

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f64_div = 0xa3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f64_eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f64_eq = 0x61

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f64_floor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f64_floor = 0x9c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f64_ge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f64_ge = 0x66

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f64_gt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_gt = 0x64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f64_le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f64_le = 0x65

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f64_load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f64_load = 0x2b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f64_lt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f64_lt = 0x63

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f64_max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f64_max = 0xa5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f64_min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f64_min = 0xa4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f64_mul

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f64_mul = 0xa2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f64_ne

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f64_ne = 0x62

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f64_nearest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64_nearest = 0x9e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f64_neg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f64_neg = 0x9a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f64_promote_f32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f64_promote_f32 = 0xbb

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f64_reinterpret_i64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f64_reinterpret_i64 = 0xbf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f64_sqrt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f64_sqrt = 0x9f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f64_store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f64_store = 0x39

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f64_sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f64_sub = 0xa1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f64_trunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f64_trunc = 0x9d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f64x2_abs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_abs = 0xfdec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f64x2_add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f64x2_add = 0xfdf0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f64x2_ceil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f64x2_ceil = 0xfd74

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f64x2_convert_low_i32x4_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f64x2_convert_low_i32x4_s = 0xfdfe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f64x2_convert_low_i32x4_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f64x2_convert_low_i32x4_u = 0xfdff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f64x2_div

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f64x2_div = 0xfdf3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f64x2_eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f64x2_eq = 0xfd47

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f64x2_extract_lane

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f64x2_extract_lane = 0xfd21

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f64x2_floor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_floor = 0xfd75

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f64x2_ge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f64x2_ge = 0xfd4c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f64x2_gt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f64x2_gt = 0xfd4a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f64x2_le

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f64x2_le = 0xfd4b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f64x2_lt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f64x2_lt = 0xfd49

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f64x2_max

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f64x2_max = 0xfdf5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f64x2_min

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f64x2_min = 0xfdf4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f64x2_mul

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f64x2_mul = 0xfdf2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f64x2_ne

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_ne = 0xfd48

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f64x2_nearest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f64x2_nearest = 0xfd94

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f64x2_neg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f64x2_neg = 0xfded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member f64x2_pmax

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          f64x2_pmax = 0xfdf7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member f64x2_pmin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            f64x2_pmin = 0xfdf6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member f64x2_promote_low_f32x4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              f64x2_promote_low_f32x4 = 0xfd5f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member f64x2_replace_lane

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                f64x2_replace_lane = 0xfd22

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member f64x2_splat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  f64x2_splat = 0xfd14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member f64x2_sqrt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    f64x2_sqrt = 0xfdef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member f64x2_sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      f64x2_sub = 0xfdf1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member f64x2_trunc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        f64x2_trunc = 0xfd7a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member global_get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          global_get = 0x23

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member global_set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            global_set = 0x24

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member grow_memory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              grow_memory = 0x40

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i16x8_abs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i16x8_abs = 0xfd80

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i16x8_add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i16x8_add = 0xfd8e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i16x8_add_sat_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_add_sat_s = 0xfd8f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i16x8_add_sat_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i16x8_add_sat_u = 0xfd90

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i16x8_all_true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i16x8_all_true = 0xfd83

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i16x8_avgr_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i16x8_avgr_u = 0xfd9b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i16x8_bitmask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i16x8_bitmask = 0xfd84

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i16x8_eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i16x8_eq = 0xfd2d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i16x8_extadd_pairwise_i8x16_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i16x8_extadd_pairwise_i8x16_s = 0xfd7c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i16x8_extadd_pairwise_i8x16_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i16x8_extadd_pairwise_i8x16_u = 0xfd7d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i16x8_extend_high_i8x16_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extend_high_i8x16_s = 0xfd88

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i16x8_extend_high_i8x16_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i16x8_extend_high_i8x16_u = 0xfd8a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i16x8_extend_low_i8x16_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i16x8_extend_low_i8x16_s = 0xfd87

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i16x8_extend_low_i8x16_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i16x8_extend_low_i8x16_u = 0xfd89

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i16x8_extmul_high_i8x16_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i16x8_extmul_high_i8x16_s = 0xfd9d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i16x8_extmul_high_i8x16_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i16x8_extmul_high_i8x16_u = 0xfd9f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i16x8_extmul_low_i8x16_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i16x8_extmul_low_i8x16_s = 0xfd9c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i16x8_extmul_low_i8x16_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i16x8_extmul_low_i8x16_u = 0xfd9e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i16x8_extract_lane_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_extract_lane_s = 0xfd18

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i16x8_extract_lane_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i16x8_extract_lane_u = 0xfd19

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i16x8_ge_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i16x8_ge_s = 0xfd35

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i16x8_ge_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i16x8_ge_u = 0xfd36

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i16x8_gt_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i16x8_gt_s = 0xfd31

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i16x8_gt_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i16x8_gt_u = 0xfd32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i16x8_le_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i16x8_le_s = 0xfd33

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i16x8_le_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i16x8_le_u = 0xfd34

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i16x8_load8x8_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_load8x8_s = 0xfd01

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i16x8_load8x8_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i16x8_load8x8_u = 0xfd02

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i16x8_lt_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i16x8_lt_s = 0xfd2f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i16x8_lt_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i16x8_lt_u = 0xfd30

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i16x8_max_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i16x8_max_s = 0xfd98

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i16x8_max_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i16x8_max_u = 0xfd99

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i16x8_min_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i16x8_min_s = 0xfd96

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i16x8_min_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i16x8_min_u = 0xfd97

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i16x8_mul

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_mul = 0xfd95

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i16x8_narrow_i32x4_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i16x8_narrow_i32x4_s = 0xfd85

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i16x8_narrow_i32x4_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i16x8_narrow_i32x4_u = 0xfd86

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i16x8_ne

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i16x8_ne = 0xfd2e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i16x8_neg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i16x8_neg = 0xfd81

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i16x8_q15mulr_sat_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i16x8_q15mulr_sat_s = 0xfd82

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i16x8_replace_lane

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i16x8_replace_lane = 0xfd1a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i16x8_shl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i16x8_shl = 0xfd8b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i16x8_shr_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i16x8_shr_s = 0xfd8c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i16x8_shr_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i16x8_shr_u = 0xfd8d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i16x8_splat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i16x8_splat = 0xfd10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i16x8_sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i16x8_sub = 0xfd91

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i16x8_sub_sat_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i16x8_sub_sat_s = 0xfd92

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i16x8_sub_sat_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i16x8_sub_sat_u = 0xfd93

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i31_get_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i31_get_s = 0xfb21

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i31_get_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i31_get_u = 0xfb22

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i31_new

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i31_new = 0xfb20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_add = 0x6a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_and

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_and = 0x71

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_atomic_load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_atomic_load = 0xfe10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_atomic_load16_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_atomic_load16_u = 0xfe13

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_atomic_load8_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_atomic_load8_u = 0xfe12

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_atomic_rmw_add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_atomic_rmw_add = 0xfe1e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_atomic_rmw_and

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_atomic_rmw_and = 0xfe2c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_atomic_rmw_cmpxchg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw_cmpxchg = 0xfe48

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_atomic_rmw_or

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_atomic_rmw_or = 0xfe33

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_atomic_rmw_sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_atomic_rmw_sub = 0xfe25

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_atomic_rmw_xchg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_atomic_rmw_xchg = 0xfe41

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_atomic_rmw_xor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_atomic_rmw_xor = 0xfe3a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_atomic_rmw16_add_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_atomic_rmw16_add_u = 0xfe21

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_atomic_rmw16_and_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_atomic_rmw16_and_u = 0xfe2f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_atomic_rmw16_cmpxchg_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_atomic_rmw16_cmpxchg_u = 0xfe4b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_atomic_rmw16_or_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw16_or_u = 0xfe36

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_atomic_rmw16_sub_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_atomic_rmw16_sub_u = 0xfe28

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_atomic_rmw16_xchg_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_atomic_rmw16_xchg_u = 0xfe44

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_atomic_rmw16_xor_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_atomic_rmw16_xor_u = 0xfe3d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_atomic_rmw8_add_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_atomic_rmw8_add_u = 0xfe20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_atomic_rmw8_and_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_atomic_rmw8_and_u = 0xfe2e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_atomic_rmw8_cmpxchg_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_atomic_rmw8_cmpxchg_u = 0xfe4a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_atomic_rmw8_or_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_atomic_rmw8_or_u = 0xfe35

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_atomic_rmw8_sub_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_atomic_rmw8_sub_u = 0xfe27

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_atomic_rmw8_xchg_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_atomic_rmw8_xchg_u = 0xfe43

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_atomic_rmw8_xor_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_atomic_rmw8_xor_u = 0xfe3c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_atomic_store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_atomic_store = 0xfe17

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_atomic_store16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_atomic_store16 = 0xfe1a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_atomic_store8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_atomic_store8 = 0xfe19

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_atomic_wait

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_atomic_wait = 0xfe01

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_clz

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_clz = 0x67

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_const

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_const = 0x41

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_ctz

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_ctz = 0x68

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_div_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_div_s = 0x6d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_div_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_div_u = 0x6e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_eq = 0x46

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_eqz

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_eqz = 0x45

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_extend16_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_extend16_s = 0xc1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_extend8_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_extend8_s = 0xc0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_ge_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_ge_s = 0x4e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_ge_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_ge_u = 0x4f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_gt_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_gt_s = 0x4a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_gt_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_gt_u = 0x4b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_le_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_le_s = 0x4c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_le_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_le_u = 0x4d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_load = 0x28

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_load16_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_load16_s = 0x2e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_load16_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_load16_u = 0x2f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_load8_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_load8_s = 0x2c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_load8_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_load8_u = 0x2d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_lt_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_lt_s = 0x48

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_lt_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_lt_u = 0x49

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_mul

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_mul = 0x6c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_ne

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_ne = 0x47

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_or

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_or = 0x72

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_popcnt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_popcnt = 0x69

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_reinterpret_f32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_reinterpret_f32 = 0xbc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_rem_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_rem_s = 0x6f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_rem_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_rem_u = 0x70

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_rotl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_rotl = 0x77

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_rotr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_rotr = 0x78

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_shl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_shl = 0x74

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_shr_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_shr_s = 0x75

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_shr_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_shr_u = 0x76

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_store

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_store = 0x36

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_store16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_store16 = 0x3b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_store8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_store8 = 0x3a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_sub = 0x6b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_trunc_f32_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_trunc_f32_s = 0xa8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_trunc_f32_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_trunc_f32_u = 0xa9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32_trunc_f64_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32_trunc_f64_s = 0xaa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32_trunc_f64_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32_trunc_f64_u = 0xab

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32_trunc_sat_f32_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32_trunc_sat_f32_s = 0xfc00

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32_trunc_sat_f32_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32_trunc_sat_f32_u = 0xfc01

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32_trunc_sat_f64_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32_trunc_sat_f64_s = 0xfc02

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32_trunc_sat_f64_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32_trunc_sat_f64_u = 0xfc03

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32_wrap_i64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32_wrap_i64 = 0xa7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32_xor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32_xor = 0x73

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32x4_abs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32x4_abs = 0xfda0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32x4_add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_add = 0xfdae

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32x4_all_true

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32x4_all_true = 0xfda3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32x4_bitmask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        i32x4_bitmask = 0xfda4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member i32x4_dot_i16x8_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          i32x4_dot_i16x8_s = 0xfdba

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member i32x4_eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i32x4_eq = 0xfd37

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member i32x4_extadd_pairwise_i16x8_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i32x4_extadd_pairwise_i16x8_s = 0xfd7e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member i32x4_extadd_pairwise_i16x8_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                i32x4_extadd_pairwise_i16x8_u = 0xfd7f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member i32x4_extend_high_i16x8_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i32x4_extend_high_i16x8_s = 0xfda8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member i32x4_extend_high_i16x8_u

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    i32x4_extend_high_i16x8_u = 0xfdaa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member i32x4_extend_low_i16x8_s

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      i32x4_extend_low_i16x8_s = 0xfda7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member i32x4_extend_low_i16x8_u